//Copyright (c) Microsoft Corporation.  All rights reserved.

#pragma once

namespace  Microsoft { namespace WindowsAPICodePack { namespace DirectX { namespace Direct3D10 {

using namespace System;
using namespace Microsoft::WindowsAPICodePack::DirectX;
using namespace Microsoft::WindowsAPICodePack::DirectX::Direct3DCommon;
using namespace Microsoft::WindowsAPICodePack::DirectX::DXGI;

namespace D3D10 = Microsoft::WindowsAPICodePack::DirectX::Direct3D10;

/// <summary>
/// Describes the blend state.
/// <para>(Also see DirectX SDK: D3D10_BLEND_DESC)</para>
/// </summary>
public ref struct BlendDescription 
{
public:
    /// <summary>
    /// Determines whether or not to use alpha-to-coverage as a multisampling technique when setting a pixel to a rendertarget.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.AlphaToCoverageEnable)</para>
    /// </summary>
    property Boolean AlphaToCoverageEnable
    {
        Boolean get()
        {
            return nativeObject->AlphaToCoverageEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->AlphaToCoverageEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// Enable (or disable) blending. There are eight elements in this array; these correspond to the eight rendertargets that can be set to output-merger stage at one time.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.BlendEnable)</para>
    /// </summary>
    property BoolIndexer^ BlendEnable
    {
        BoolIndexer^ get()
        {
            if ( blendEnableArrayIndexer== nullptr)
            {
                blendEnableArrayIndexer = gcnew BoolIndexer(BlendEnableArrayLength, nativeObject->BlendEnable);
            }
            return blendEnableArrayIndexer;
        }
    }
    /// <summary>
    /// This blend option specifies the first RGB data source and includes an optional pre-blend operation.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.SrcBlend)</para>
    /// </summary>
    property Blend SrcBlend
    {
        Blend get()
        {
            return (Blend)(nativeObject->SrcBlend);
        }
        void set(Blend value)
        {
            nativeObject->SrcBlend = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend option specifies the second RGB data source and includes an optional pre-blend operation.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.DestBlend)</para>
    /// </summary>
    property Blend DestBlend
    {
        Blend get()
        {
            return (Blend)(nativeObject->DestBlend);
        }
        void set(Blend value)
        {
            nativeObject->DestBlend = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend operation defines how to combine the RGB data sources.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.BlendOp)</para>
    /// </summary>
    property D3D10::BlendOperation BlendOperation
    {
        D3D10::BlendOperation get()
        {
            return (D3D10::BlendOperation)(nativeObject->BlendOp);
        }
        void set(D3D10::BlendOperation value)
        {
            nativeObject->BlendOp = (D3D10_BLEND_OP)value;
        }
    }
    /// <summary>
    /// This blend option specifies the first alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.SrcBlendAlpha)</para>
    /// </summary>
    property Blend SrcBlendAlpha
    {
        Blend get()
        {
            return (Blend)(nativeObject->SrcBlendAlpha);
        }
        void set(Blend value)
        {
            nativeObject->SrcBlendAlpha = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend option specifies the second alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.DestBlendAlpha)</para>
    /// </summary>
    property Blend DestBlendAlpha
    {
        Blend get()
        {
            return (Blend)(nativeObject->DestBlendAlpha);
        }
        void set(Blend value)
        {
            nativeObject->DestBlendAlpha = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend operation defines how to combine the alpha data sources.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.BlendOpAlpha)</para>
    /// </summary>
    property D3D10::BlendOperation BlendOperationAlpha
    {
        D3D10::BlendOperation get()
        {
            return (D3D10::BlendOperation)(nativeObject->BlendOpAlpha);
        }
        void set(D3D10::BlendOperation value)
        {
            nativeObject->BlendOpAlpha = (D3D10_BLEND_OP)value;
        }
    }
    /// <summary>
    /// A per-pixel write mask that allows control over which components can be written (see <see cref="ColorWriteEnable"/>)<seealso cref="ColorWriteEnable"/>.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC.RenderTargetWriteMask)</para>
    /// </summary>
    property ByteIndexer^ RenderTargetWriteMask
    {
        ByteIndexer^ get()
        {
            if (renderTargetWriteMaskIndexer == nullptr)
            {
                renderTargetWriteMaskIndexer =
                    gcnew ByteIndexer(RenderTargetWriteMaskArrayLength,
                    nativeObject->RenderTargetWriteMask);
            }
            return renderTargetWriteMaskIndexer;
        }
    }
public:
    BlendDescription()
    {
        nativeObject.Set(new D3D10_BLEND_DESC());
    }
internal:
    AutoPointer<D3D10_BLEND_DESC> nativeObject;
internal:
    BlendDescription(D3D10_BLEND_DESC* pBlendDescription)
    {
        nativeObject.Set(pBlendDescription);
    }

    BlendDescription(D3D10_BLEND_DESC* pBlendDescription, bool deletable)
    {
        nativeObject.Set(pBlendDescription, deletable);
    }
private:
    ByteIndexer^ renderTargetWriteMaskIndexer;
    BoolIndexer^ blendEnableArrayIndexer;
    literal int RenderTargetWriteMaskArrayLength = 8;
    literal int BlendEnableArrayLength = 8;
};
/// <summary>
/// Describes the blend state for a render target for a Direct3D 10.1 device
/// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1)</para>
/// </summary>
public ref struct RenderTargetBlendDescription1 
{
public:
    /// <summary>
    /// Enable (or disable) blending.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.BlendEnable)</para>
    /// </summary>
    property Boolean BlendEnable
    {
        Boolean get()
        {
            return nativeObject->BlendEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->BlendEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// This blend option specifies the first RGB data source and includes an optional pre-blend operation.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.SrcBlend)</para>
    /// </summary>
    property Blend SrcBlend
    {
        Blend get()
        {
            return (Blend)(nativeObject->SrcBlend);
        }
        void set(Blend value)
        {
            nativeObject->SrcBlend = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend option specifies the second RGB data source and includes an optional pre-blend operation.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.DestBlend)</para>
    /// </summary>
    property Blend DestBlend
    {
        Blend get()
        {
            return (Blend)(nativeObject->DestBlend);
        }
        void set(Blend value)
        {
            nativeObject->DestBlend = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend operation defines how to combine the RGB data sources.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.BlendOp)</para>
    /// </summary>
    property D3D10::BlendOperation BlendOperation
    {
        D3D10::BlendOperation get()
        {
            return (D3D10::BlendOperation)(nativeObject->BlendOp);
        }
        void set(D3D10::BlendOperation value)
        {
            nativeObject->BlendOp = (D3D10_BLEND_OP)value;
        }
    }
    /// <summary>
    /// This blend option specifies the first alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.SrcBlendAlpha)</para>
    /// </summary>
    property Blend SrcBlendAlpha
    {
        Blend get()
        {
            return (Blend)(nativeObject->SrcBlendAlpha);
        }
        void set(Blend value)
        {
            nativeObject->SrcBlendAlpha = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend option specifies the second alpha data source and includes an optional pre-blend operation. Blend options that end in _COLOR are not allowed.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.DestBlendAlpha)</para>
    /// </summary>
    property Blend DestBlendAlpha
    {
        Blend get()
        {
            return (Blend)(nativeObject->DestBlendAlpha);
        }
        void set(Blend value)
        {
            nativeObject->DestBlendAlpha = (D3D10_BLEND)value;
        }
    }
    /// <summary>
    /// This blend operation defines how to combine the alpha data sources.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.BlendOpAlpha)</para>
    /// </summary>
    property D3D10::BlendOperation BlendOperationAlpha
    {
        D3D10::BlendOperation get()
        {
            return (D3D10::BlendOperation)(nativeObject->BlendOpAlpha);
        }
        void set(D3D10::BlendOperation value)
        {
            nativeObject->BlendOpAlpha = (D3D10_BLEND_OP)value;
        }
    }
    /// <summary>
    /// A write mask.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_BLEND_DESC1.RenderTargetWriteMask)</para>
    /// </summary>
    property Byte RenderTargetWriteMask
    {
        Byte get()
        {
            return (Byte)(nativeObject->RenderTargetWriteMask);
        }
        void set(Byte value)
        {
            nativeObject->RenderTargetWriteMask = (UINT8)value;
        }
    }
public:
    RenderTargetBlendDescription1()
    {
        nativeObject.Set(new D3D10_RENDER_TARGET_BLEND_DESC1());
    }
internal:
    AutoPointer<D3D10_RENDER_TARGET_BLEND_DESC1> nativeObject;
internal:
    RenderTargetBlendDescription1(D3D10_RENDER_TARGET_BLEND_DESC1* pRenderTargetBlendDescription1)
    {
        nativeObject.Set(pRenderTargetBlendDescription1);
    }
    RenderTargetBlendDescription1(D3D10_RENDER_TARGET_BLEND_DESC1* pRenderTargetBlendDescription1, bool deletable)
    {
        nativeObject.Set(pRenderTargetBlendDescription1, deletable);
    }
};
/// <summary>
/// Describes the blend state for a Direct3D 10.1 device.
/// <para>(Also see DirectX SDK: D3D10_BLEND_DESC1)</para>
/// </summary>
public ref struct BlendDescription1 
{
public:
    /// <summary>
    /// Determines whether or not to use the alpha-to-coverage multisampling technique when setting a render-target pixel.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC1.AlphaToCoverageEnable)</para>
    /// </summary>
    property Boolean AlphaToCoverageEnable
    {
        Boolean get()
        {
            return nativeObject->AlphaToCoverageEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->AlphaToCoverageEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// Set to TRUE to enable independent blending in simultaneous render targets.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC1.IndependentBlendEnable)</para>
    /// </summary>
    property Boolean IndependentBlendEnable
    {
        Boolean get()
        {
            return nativeObject->IndependentBlendEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->IndependentBlendEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// An array of render-target-blend descriptions (see <see cref="RenderTargetBlendDescription1"/>)<seealso cref="RenderTargetBlendDescription1"/>; these correspond to the eight rendertargets that can be set to the output-merger stage at one time.
    /// <para>(Also see DirectX SDK: D3D10_BLEND_DESC1.RenderTarget)</para>
    /// </summary>
    property RenderTargetBlendDescription1^ RenderTarget[int]
    {
        RenderTargetBlendDescription1^ get(int i)
        {
            if (i < 0 || i >= RenderTargetArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 8");

            return gcnew RenderTargetBlendDescription1(&(nativeObject->RenderTarget[i]), false);
        }

        void set(int i, RenderTargetBlendDescription1^ value)
        {
            if (i < 0 || i >= RenderTargetArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 8");

            memcpy(&(nativeObject->RenderTarget[i]), value->nativeObject.Get(), sizeof(D3D10_RENDER_TARGET_BLEND_DESC1));
        }
    }

public:
    BlendDescription1()
    {
        nativeObject.Set(new D3D10_BLEND_DESC1());
    }
internal:
    AutoPointer<D3D10_BLEND_DESC1> nativeObject;
internal:
    BlendDescription1(D3D10_BLEND_DESC1* pBlendDescription1)
    {
        nativeObject.Set(pBlendDescription1);
    }
    BlendDescription1(D3D10_BLEND_DESC1* pBlendDescription1, bool deletable)
    {
        nativeObject.Set(pBlendDescription1, deletable);
    }
public:
    literal int RenderTargetArrayLength = 8;
};
/// <summary>
/// Defines a 3D box.
/// <para>(Also see DirectX SDK: D3D10_BOX)</para>
/// </summary>
public ref struct Box 
{
public:
    /// <summary>
    /// The x position of the left hand side of the box.
    /// <para>(Also see DirectX SDK: D3D10_BOX.left)</para>
    /// </summary>
    property UInt32 Left
    {
        UInt32 get()
        {
            return (nativeObject->left);
        }
        void set(UInt32 value)
        {
            nativeObject->left = value;
        }
    }
    /// <summary>
    /// The y position of the top of the box.
    /// <para>(Also see DirectX SDK: D3D10_BOX.top)</para>
    /// </summary>
    property UInt32 Top
    {
        UInt32 get()
        {
            return (nativeObject->top);
        }
        void set(UInt32 value)
        {
            nativeObject->top = value;
        }
    }
    /// <summary>
    /// The z position of the front of the box.
    /// <para>(Also see DirectX SDK: D3D10_BOX.front)</para>
    /// </summary>
    property UInt32 Front
    {
        UInt32 get()
        {
            return (nativeObject->front);
        }
        void set(UInt32 value)
        {
            nativeObject->front = value;
        }
    }
    /// <summary>
    /// The x position of the right hand side of the box.
    /// <para>(Also see DirectX SDK: D3D10_BOX.right)</para>
    /// </summary>
    property UInt32 Right
    {
        UInt32 get()
        {
            return (nativeObject->right);
        }
        void set(UInt32 value)
        {
            nativeObject->right = value;
        }
    }
    /// <summary>
    /// The y position of the bottom of the box.
    /// <para>(Also see DirectX SDK: D3D10_BOX.bottom)</para>
    /// </summary>
    property UInt32 Bottom
    {
        UInt32 get()
        {
            return (nativeObject->bottom);
        }
        void set(UInt32 value)
        {
            nativeObject->bottom = value;
        }
    }
    /// <summary>
    /// The z position of the back of the box.
    /// <para>(Also see DirectX SDK: D3D10_BOX.back)</para>
    /// </summary>
    property UInt32 Back
    {
        UInt32 get()
        {
            return (nativeObject->back);
        }
        void set(UInt32 value)
        {
            nativeObject->back = value;
        }
    }
public:
    Box()
    {
        nativeObject.Set(new D3D10_BOX());
    }
internal:
    AutoPointer<D3D10_BOX> nativeObject;
internal:
    Box(D3D10_BOX* pBox)
    {
        nativeObject.Set(pBox);
    }
    Box(D3D10_BOX* pBox, bool deletable)
    {
        nativeObject.Set(pBox, deletable);
    }
};
/// <summary>
/// Describes a buffer resource.
/// <para>(Also see DirectX SDK: D3D10_BUFFER_DESC)</para>
/// </summary>
public ref struct BufferDescription 
{
public:
    /// <summary>
    /// Size of the buffer in bytes.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_DESC.ByteWidth)</para>
    /// </summary>
    property UInt32 ByteWidth
    {
        UInt32 get()
        {
            return (nativeObject->ByteWidth);
        }
        void set(UInt32 value)
        {
            nativeObject->ByteWidth = value;
        }
    }
    /// <summary>
    /// Identify how the buffer is expected to be read from and written to. Frequency of update is a key factor. The most common value is typically Usage_DEFAULT; see Usage for all possible values.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_DESC.Usage)</para>
    /// </summary>
    property D3D10::Usage Usage
    {
        D3D10::Usage get()
        {
            return (D3D10::Usage)(nativeObject->Usage);
        }
        void set(D3D10::Usage value)
        {
            nativeObject->Usage = (D3D10_USAGE)value;
        }
    }
    /// <summary>
    /// Identify how the buffer will be bound to the pipeline. Applications can logicaly OR flags together (see <see cref="BindFlag"/>)<seealso cref="BindFlag"/> to indicate that the buffer can be accessed in different ways.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_DESC.BindFlags)</para>
    /// </summary>
    property BindFlag BindFlags
    {
        BindFlag get()
        {
            return (BindFlag)(nativeObject->BindFlags);
        }
        void set(BindFlag value)
        {
            nativeObject->BindFlags = static_cast<UINT>(value);
        }
    }
    /// <summary>
    /// CPU access flags (see <see cref="CpuAccessFlag"/>)<seealso cref="CpuAccessFlag"/> or 0 if no CPU access is necessary. Applications can logicaly OR flags together.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_DESC.CPUAccessFlags)</para>
    /// </summary>
    property CpuAccessFlag CPUAccessFlags
    {
        CpuAccessFlag get()
        {
            return (CpuAccessFlag)(nativeObject->CPUAccessFlags);
        }
        void set(CpuAccessFlag value)
        {
            nativeObject->CPUAccessFlags = static_cast<UINT>(value);
        }
    }
    /// <summary>
    /// Miscellaneous flags (see <see cref="ResourceMiscFlag"/>)<seealso cref="ResourceMiscFlag"/> or 0 if unused. Applications can logically OR flags together.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_DESC.MiscFlags)</para>
    /// </summary>
    property ResourceMiscFlag MiscFlags
    {
        ResourceMiscFlag get()
        {
            return (ResourceMiscFlag)(nativeObject->MiscFlags);
        }
        void set(ResourceMiscFlag value)
        {
            nativeObject->MiscFlags = static_cast<UINT>(value);
        }
    }
public:
    BufferDescription()
    {
        nativeObject.Set(new D3D10_BUFFER_DESC());
    }
internal:
    AutoPointer<D3D10_BUFFER_DESC> nativeObject;
internal:
    BufferDescription(D3D10_BUFFER_DESC* pBufferDescription)
    {
        nativeObject.Set(pBufferDescription);
    }
    BufferDescription(D3D10_BUFFER_DESC* pBufferDescription, bool deletable)
    {
        nativeObject.Set(pBufferDescription, deletable);
    }
};
/// <summary>
/// Specifies the elements from a buffer resource to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_BUFFER_RTV)</para>
/// </summary>
public ref struct BufferRenderTargetView 
{
public:
    /// <summary>
    /// The offset (that is, the number of elements) between the beginning of the buffer and the first element that is to be used in the view, starting at 0.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_RTV.ElementOffset)</para>
    /// </summary>
    property UInt32 ElementOffset
    {
        UInt32 get()
        {
            return (nativeObject->ElementOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->ElementOffset = value;
        }
    }
    /// <summary>
    /// The number of elements in the view.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_RTV.ElementWidth)</para>
    /// </summary>
    property UInt32 ElementWidth
    {
        UInt32 get()
        {
            return (nativeObject->ElementWidth);
        }
        void set(UInt32 value)
        {
            nativeObject->ElementWidth = value;
        }
    }
public:
    BufferRenderTargetView()
    {
        nativeObject.Set(new D3D10_BUFFER_RTV());
    }
internal:
    AutoPointer<D3D10_BUFFER_RTV> nativeObject;
internal:
    BufferRenderTargetView(D3D10_BUFFER_RTV* pBufferRenderTargetView)
    {
        nativeObject.Set(pBufferRenderTargetView);
    }
    BufferRenderTargetView(D3D10_BUFFER_RTV* pBufferRenderTargetView, bool deletable)
    {
        nativeObject.Set(pBufferRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the elements in a buffer resource to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_BUFFER_SRV)</para>
/// </summary>
public ref struct BufferShaderResourceView 
{
public:
    /// <summary>
    /// The offset of the first element in the view to access, relative to element 0.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_SRV.ElementOffset)</para>
    /// </summary>
    property UInt32 ElementOffset
    {
        UInt32 get()
        {
            return (nativeObject->ElementOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->ElementOffset = value;
        }
    }
    /// <summary>
    /// The total number of elements in the view.
    /// <para>(Also see DirectX SDK: D3D10_BUFFER_SRV.ElementWidth)</para>
    /// </summary>
    property UInt32 ElementWidth
    {
        UInt32 get()
        {
            return (nativeObject->ElementWidth);
        }
        void set(UInt32 value)
        {
            nativeObject->ElementWidth = value;
        }
    }
public:
    BufferShaderResourceView()
    {
        nativeObject.Set(new D3D10_BUFFER_SRV());
    }
internal:
    AutoPointer<D3D10_BUFFER_SRV> nativeObject;
internal:
    BufferShaderResourceView(D3D10_BUFFER_SRV* pBufferShaderResourceView)
    {
        nativeObject.Set(pBufferShaderResourceView);
    }
    BufferShaderResourceView(D3D10_BUFFER_SRV* pBufferShaderResourceView, bool deletable)
    {
        nativeObject.Set(pBufferShaderResourceView, deletable);
    }
};
/// <summary>
/// Describes a counter.
/// <para>(Also see DirectX SDK: D3D10_COUNTER_DESC)</para>
/// </summary>
public ref struct CounterDescription 
{
public:
    /// <summary>
    /// Type of counter (see <see cref="Counter"/>)<seealso cref="Counter"/>.
    /// <para>(Also see DirectX SDK: D3D10_COUNTER_DESC.Counter)</para>
    /// </summary>
    property D3D10::Counter Counter
    {
        D3D10::Counter get()
        {
            return (D3D10::Counter)(nativeObject->Counter);
        }
        void set(D3D10::Counter value)
        {
            nativeObject->Counter = (D3D10_COUNTER)value;
        }
    }
    /// <summary>
    /// Reserved.
    /// <para>(Also see DirectX SDK: D3D10_COUNTER_DESC.MiscFlags)</para>
    /// </summary>
    property UInt32 MiscFlags
    {
        UInt32 get()
        {
            return (nativeObject->MiscFlags);
        }
        void set(UInt32 value)
        {
            nativeObject->MiscFlags = value;
        }
    }
public:
    CounterDescription()
    {
        nativeObject.Set(new D3D10_COUNTER_DESC());
    }
internal:
    AutoPointer<D3D10_COUNTER_DESC> nativeObject;
internal:
    CounterDescription(D3D10_COUNTER_DESC* pCounterDescription)
    {
        nativeObject.Set(pCounterDescription);
    }
    CounterDescription(D3D10_COUNTER_DESC* pCounterDescription, bool deletable)
    {
        nativeObject.Set(pCounterDescription, deletable);
    }
};
/// <summary>
/// Information about the video card's performance counter capabilities.
/// <para>(Also see DirectX SDK: D3D10_COUNTER_INFO)</para>
/// </summary>
public ref struct CounterInformation 
{
public:
    /// <summary>
    /// Largest device-dependent counter ID that the device supports. If none are supported, this value will be 0. Otherwise it will be greater than or equal to DeviceDependent0. See Counter.
    /// <para>(Also see DirectX SDK: D3D10_COUNTER_INFO.LastDeviceDependentCounter)</para>
    /// </summary>
    property Counter LastDeviceDependentCounter
    {
        Counter get()
        {
            return (Counter)(nativeObject->LastDeviceDependentCounter);
        }
        void set(Counter value)
        {
            nativeObject->LastDeviceDependentCounter = (D3D10_COUNTER)value;
        }
    }
    /// <summary>
    /// Number of counters that can be simultaneously supported.
    /// <para>(Also see DirectX SDK: D3D10_COUNTER_INFO.NumSimultaneousCounters)</para>
    /// </summary>
    property UInt32 NumSimultaneousCounters
    {
        UInt32 get()
        {
            return (nativeObject->NumSimultaneousCounters);
        }
        void set(UInt32 value)
        {
            nativeObject->NumSimultaneousCounters = value;
        }
    }
    /// <summary>
    /// Number of detectable parallel units that the counter is able to discern. Values are 1 ~ 4. Use NumDetectableParallelUnits to interpret the values of the VERTEX_PROCESSING, GEOMETRY_PROCESSING, PIXEL_PROCESSING, and OTHER_GPU_PROCESSING counters. See Asynchronous.GetData for an equation.
    /// <para>(Also see DirectX SDK: D3D10_COUNTER_INFO.NumDetectableParallelUnits)</para>
    /// </summary>
    property Byte NumDetectableParallelUnits
    {
        Byte get()
        {
            return (Byte)(nativeObject->NumDetectableParallelUnits);
        }
        void set(Byte value)
        {
            nativeObject->NumDetectableParallelUnits = (UINT8)value;
        }
    }
public:
    CounterInformation()
    {
        nativeObject.Set(new D3D10_COUNTER_INFO());
    }
internal:
    AutoPointer<D3D10_COUNTER_INFO> nativeObject;
internal:
    CounterInformation(D3D10_COUNTER_INFO* pCounterInfo)
    {
        nativeObject.Set(pCounterInfo);
    }
    CounterInformation(D3D10_COUNTER_INFO* pCounterInfo, bool deletable)
    {
        nativeObject.Set(pCounterInfo, deletable);
    }
};
/// <summary>
/// Describes the stencil operations that can be performed based on the results of stencil test.
/// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCILOP_DESC)</para>
/// </summary>
public ref struct DepthStencilopDescription 
{
public:
    /// <summary>
    /// A member of the StencilOperation enumerated type that describes the stencil operation to perform when stencil testing fails. The default value is StencilOperation_KEEP.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCILOP_DESC.StencilFailOp)</para>
    /// </summary>
    property StencilOperation StencilFailOperation
    {
        StencilOperation get()
        {
            return (StencilOperation)(nativeObject->StencilFailOp);
        }
        void set(StencilOperation value)
        {
            nativeObject->StencilFailOp = (D3D10_STENCIL_OP)value;
        }
    }
    /// <summary>
    /// A member of the StencilOperation enumerated type that describes the stencil operation to perform when stencil testing passes and depth testing fails. The default value is StencilOperation_KEEP.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCILOP_DESC.StencilDepthFailOp)</para>
    /// </summary>
    property StencilOperation StencilDepthFailOperation
    {
        StencilOperation get()
        {
            return (StencilOperation)(nativeObject->StencilDepthFailOp);
        }
        void set(StencilOperation value)
        {
            nativeObject->StencilDepthFailOp = (D3D10_STENCIL_OP)value;
        }
    }
    /// <summary>
    /// A member of the StencilOperation enumerated type that describes the stencil operation to perform when stencil testing and depth testing both pass. The default value is StencilOperation_KEEP.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCILOP_DESC.StencilPassOp)</para>
    /// </summary>
    property StencilOperation StencilPassOperation
    {
        StencilOperation get()
        {
            return (StencilOperation)(nativeObject->StencilPassOp);
        }
        void set(StencilOperation value)
        {
            nativeObject->StencilPassOp = (D3D10_STENCIL_OP)value;
        }
    }
    /// <summary>
    /// A member of the ComparisonFunction enumerated type that describes how stencil data is compared against existing stencil data. The default value is Always.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCILOP_DESC.StencilFunc)</para>
    /// </summary>
    property ComparisonFunction StencilFunction
    {
        ComparisonFunction get()
        {
            return (ComparisonFunction)(nativeObject->StencilFunc);
        }
        void set(ComparisonFunction value)
        {
            nativeObject->StencilFunc = (D3D10_COMPARISON_FUNC)value;
        }
    }
public:
    DepthStencilopDescription()
    {
        nativeObject.Set(new D3D10_DEPTH_STENCILOP_DESC());
    }
internal:
    AutoPointer<D3D10_DEPTH_STENCILOP_DESC> nativeObject;
internal:
    DepthStencilopDescription(D3D10_DEPTH_STENCILOP_DESC* pDepthStencilopDescription)
    {
        nativeObject.Set(pDepthStencilopDescription);
    }
    DepthStencilopDescription(D3D10_DEPTH_STENCILOP_DESC* pDepthStencilopDescription, bool deletable)
    {
        nativeObject.Set(pDepthStencilopDescription, deletable);
    }
};
/// <summary>
/// Describes depth-stencil state.
/// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC)</para>
/// </summary>
public ref struct DepthStencilDescription 
{
public:
    /// <summary>
    /// A Boolean value that enables depth testing.  The default value is TRUE.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.DepthEnable)</para>
    /// </summary>
    property Boolean DepthEnable
    {
        Boolean get()
        {
            return nativeObject->DepthEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->DepthEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// A member of the DepthWriteMask enumerated type that identifies a portion of the depth-stencil buffer that can be modified by depth data.  The default value is DepthWriteMask_ALL.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.DepthWriteMask)</para>
    /// </summary>
    property DepthWriteMask _DepthWriteMask
    {
        DepthWriteMask get()
        {
            return (DepthWriteMask)(nativeObject->DepthWriteMask);
        }
        void set(DepthWriteMask value)
        {
            nativeObject->DepthWriteMask = (D3D10_DEPTH_WRITE_MASK)value;
        }
    }
    /// <summary>
    /// A member of the ComparisonFunction enumerated type that defines how depth data is compared against existing depth data.  The default value is Less
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.DepthFunc)</para>
    /// </summary>
    property ComparisonFunction DepthFunc
    {
        ComparisonFunction get()
        {
            return (ComparisonFunction)(nativeObject->DepthFunc);
        }
        void set(ComparisonFunction value)
        {
            nativeObject->DepthFunc = (D3D10_COMPARISON_FUNC)value;
        }
    }
    /// <summary>
    /// A Boolean value that enables stencil testing.  The default value is FALSE.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.StencilEnable)</para>
    /// </summary>
    property Boolean StencilEnable
    {
        Boolean get()
        {
            return nativeObject->StencilEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->StencilEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// A value that identifies a portion of the depth-stencil buffer for reading stencil data.  The default value is D3D10_DEFAULT_STENCIL_READ_MASK.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.StencilReadMask)</para>
    /// </summary>
    property Byte StencilReadMask
    {
        Byte get()
        {
            return (Byte)(nativeObject->StencilReadMask);
        }
        void set(Byte value)
        {
            nativeObject->StencilReadMask = (UINT8)value;
        }
    }
    /// <summary>
    /// A value that identifies a portion of the depth-stencil buffer for writing stencil data. The default value is D3D10_DEFAULT_STENCIL_WRITE_MASK.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.StencilWriteMask)</para>
    /// </summary>
    property Byte StencilWriteMask
    {
        Byte get()
        {
            return (Byte)(nativeObject->StencilWriteMask);
        }
        void set(Byte value)
        {
            nativeObject->StencilWriteMask = (UINT8)value;
        }
    }
    /// <summary>
    /// A DepthStencilopDescription structure that identifies how to use the results of the depth test and the stencil test for pixels whose surface normal is facing toward the camera.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.FrontFace)</para>
    /// </summary>
    property DepthStencilopDescription^ FrontFace
    {
        DepthStencilopDescription^ get()
        {
            return gcnew DepthStencilopDescription(&(nativeObject->FrontFace), false);
        }
        void set(DepthStencilopDescription^ value)
        {
            memcpy(&(nativeObject->FrontFace), (void*)(value->nativeObject.Get()), sizeof(D3D10_DEPTH_STENCILOP_DESC));
        }
    }
    /// <summary>
    /// A DepthStencilopDescription structure that identifies how to use the results of the depth test and the stencil test for pixels whose surface normal is facing away from the camera.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_DESC.BackFace)</para>
    /// </summary>
    property DepthStencilopDescription^ BackFace
    {
        DepthStencilopDescription^ get()
        {
            return gcnew DepthStencilopDescription(&(nativeObject->BackFace), false);
        }
        void set(DepthStencilopDescription^ value)
        {
            memcpy(&(nativeObject->BackFace), (void*)(value->nativeObject.Get()), sizeof(D3D10_DEPTH_STENCILOP_DESC));
        }
    }
public:
    DepthStencilDescription()
    {
        nativeObject.Set(new D3D10_DEPTH_STENCIL_DESC());
    }
internal:
    AutoPointer<D3D10_DEPTH_STENCIL_DESC> nativeObject;
internal:
    DepthStencilDescription(D3D10_DEPTH_STENCIL_DESC* pDepthStencilDescription)
    {
        nativeObject.Set(pDepthStencilDescription);
    }
    DepthStencilDescription(D3D10_DEPTH_STENCIL_DESC* pDepthStencilDescription, bool deletable)
    {
        nativeObject.Set(pDepthStencilDescription, deletable);
    }
};

/// <summary>
/// Specifies the subresource from a 1D texture that is accessable to a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_TEX1D_DSV)</para>
/// </summary>
public ref struct Texture1dDepthStencilView
{
public:
    /// <summary>
    /// The index of the first mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_DSV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
public:
    Texture1dDepthStencilView()
    {
        nativeObject.Set(new D3D10_TEX1D_DSV());
    }
internal:
    AutoPointer<D3D10_TEX1D_DSV> nativeObject;
internal:
    Texture1dDepthStencilView(D3D10_TEX1D_DSV* pTexture1dDepthStencilView)
    {
        nativeObject.Set(pTexture1dDepthStencilView);
    }
    Texture1dDepthStencilView(D3D10_TEX1D_DSV* pTexture1dDepthStencilView , bool deletable)
    {
        nativeObject.Set(pTexture1dDepthStencilView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a 1D texture to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX1D_RTV)</para>
/// </summary>
public ref struct Texture1dRenderTargetView 
{
public:
    /// <summary>
    /// The index of the mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_RTV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
public:
    Texture1dRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX1D_RTV());
    }
internal:
    AutoPointer<D3D10_TEX1D_RTV> nativeObject;
internal:
    Texture1dRenderTargetView(D3D10_TEX1D_RTV* pTexture1dRenderTargetView)
    {
        nativeObject.Set(pTexture1dRenderTargetView);
    }
    Texture1dRenderTargetView(D3D10_TEX1D_RTV* pTexture1dRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTexture1dRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a 1D texture to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX1D_SRV)</para>
/// </summary>
public ref struct Texture1dShaderResourceView 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_SRV.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of mipmap levels to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_SRV.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
public:
    Texture1dShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX1D_SRV());
    }
internal:
    AutoPointer<D3D10_TEX1D_SRV> nativeObject;
internal:
    Texture1dShaderResourceView(D3D10_TEX1D_SRV* pTexture1dShaderResourceView)
    {
        nativeObject.Set(pTexture1dShaderResourceView);
    }
    Texture1dShaderResourceView(D3D10_TEX1D_SRV* pTexture1dShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTexture1dShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of multisampled 2D textures for a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_DSV)</para>
/// </summary>
public ref struct Texture2dMultiSampleArrayDepthStencilView
{
public:
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_DSV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_DSV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture2dMultiSampleArrayDepthStencilView()
    {
        nativeObject.Set(new D3D10_TEX2DMS_ARRAY_DSV());
    }
internal:
    AutoPointer<D3D10_TEX2DMS_ARRAY_DSV> nativeObject;
internal:
    Texture2dMultiSampleArrayDepthStencilView(D3D10_TEX2DMS_ARRAY_DSV* pTexture2dMultiSampleArrayDepthStencilView)
    {
        nativeObject.Set(pTexture2dMultiSampleArrayDepthStencilView);
    }
    Texture2dMultiSampleArrayDepthStencilView(D3D10_TEX2DMS_ARRAY_DSV* pTexture2dMultiSampleArrayDepthStencilView, bool deletable)
    {
        nativeObject.Set(pTexture2dMultiSampleArrayDepthStencilView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from a an array of multisampled 2D textures to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_RTV)</para>
/// </summary>
public ref struct Texture2dMultiSampleArrayRenderTargetView 
{
public:
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_RTV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_RTV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture2dMultiSampleArrayRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX2DMS_ARRAY_RTV());
    }
internal:
    AutoPointer<D3D10_TEX2DMS_ARRAY_RTV> nativeObject;
internal:
    Texture2dMultiSampleArrayRenderTargetView(D3D10_TEX2DMS_ARRAY_RTV* pTexture2dMultiSampleArrayRenderTargetView)
    {
        nativeObject.Set(pTexture2dMultiSampleArrayRenderTargetView);
    }
    Texture2dMultiSampleArrayRenderTargetView(D3D10_TEX2DMS_ARRAY_RTV* pTexture2dMultiSampleArrayRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTexture2dMultiSampleArrayRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of multisampled 2D textures to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_SRV)</para>
/// </summary>
public ref struct Texture2dMultiSampleArrayShaderResourceView 
{
public:
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_SRV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX2DMS_ARRAY_SRV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture2dMultiSampleArrayShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX2DMS_ARRAY_SRV());
    }
internal:
    AutoPointer<D3D10_TEX2DMS_ARRAY_SRV> nativeObject;
internal:
    Texture2dMultiSampleArrayShaderResourceView(D3D10_TEX2DMS_ARRAY_SRV* pTexture2dMultiSampleArrayShaderResourceView)
    {
        nativeObject.Set(pTexture2dMultiSampleArrayShaderResourceView);
    }
    Texture2dMultiSampleArrayShaderResourceView(D3D10_TEX2DMS_ARRAY_SRV* pTexture2dMultiSampleArrayShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTexture2dMultiSampleArrayShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a multisampled 2D texture that is accessable to a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_TEX2DMS_DSV)</para>
/// </summary>
public ref struct Texture2dMultiSampleDepthStencilView
{
public:
    Texture2dMultiSampleDepthStencilView()
    {
        nativeObject.Set(new D3D10_TEX2DMS_DSV());
    }
internal:
    AutoPointer<D3D10_TEX2DMS_DSV> nativeObject;
internal:
    Texture2dMultiSampleDepthStencilView(D3D10_TEX2DMS_DSV* pTexture2dMultiSampleDepthStencilView)
    {
        nativeObject.Set(pTexture2dMultiSampleDepthStencilView);
    }
    Texture2dMultiSampleDepthStencilView(D3D10_TEX2DMS_DSV* pTexture2dMultiSampleDepthStencilView, bool deletable)
    {
        nativeObject.Set(pTexture2dMultiSampleDepthStencilView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a multisampled 2D texture to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX2DMS_RTV)</para>
/// </summary>
public ref struct Texture2dMultiSampleRenderTargetView 
{
public:
    Texture2dMultiSampleRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX2DMS_RTV());
    }
internal:
    AutoPointer<D3D10_TEX2DMS_RTV> nativeObject;
internal:
    Texture2dMultiSampleRenderTargetView(D3D10_TEX2DMS_RTV* pTexture2dMultiSampleRenderTargetView)
    {
        nativeObject.Set(pTexture2dMultiSampleRenderTargetView);
    }
    Texture2dMultiSampleRenderTargetView(D3D10_TEX2DMS_RTV* pTexture2dMultiSampleRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTexture2dMultiSampleRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from a multisampled 2D texture to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX2DMS_SRV)</para>
/// </summary>
public ref struct Texture2dMultiSampleShaderResourceView 
{
public:
    Texture2dMultiSampleShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX2DMS_SRV());
    }
internal:
    AutoPointer<D3D10_TEX2DMS_SRV> nativeObject;
internal:
    Texture2dMultiSampleShaderResourceView(D3D10_TEX2DMS_SRV* pTexture2dMultiSampleShaderResourceView)
    {
        nativeObject.Set(pTexture2dMultiSampleShaderResourceView);
    }
    Texture2dMultiSampleShaderResourceView(D3D10_TEX2DMS_SRV* pTexture2dMultiSampleShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTexture2dMultiSampleShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array 2D textures that are accessable to a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_DSV)</para>
/// </summary>
public ref struct Texture2dArrayDepthStencilView
{
public:
    /// <summary>
    /// The index of the first mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_DSV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_DSV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_DSV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture2dArrayDepthStencilView()
    {
        nativeObject.Set(new D3D10_TEX2D_ARRAY_DSV());
    }
internal:
    AutoPointer<D3D10_TEX2D_ARRAY_DSV> nativeObject;
internal:
    Texture2dArrayDepthStencilView(D3D10_TEX2D_ARRAY_DSV* pTexture2dArrayDepthStencilView)
    {
        nativeObject.Set(pTexture2dArrayDepthStencilView);
    }
    Texture2dArrayDepthStencilView(D3D10_TEX2D_ARRAY_DSV* pTexture2dArrayDepthStencilView, bool deletable)
    {
        nativeObject.Set(pTexture2dArrayDepthStencilView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of 2D textures to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_RTV)</para>
/// </summary>
public ref struct Texture2dArrayRenderTargetView 
{
public:
    /// <summary>
    /// The index of the mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_RTV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_RTV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures in the array to use in the render target view, starting from FirstArraySlice.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_RTV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture2dArrayRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX2D_ARRAY_RTV());
    }
internal:
    AutoPointer<D3D10_TEX2D_ARRAY_RTV> nativeObject;
internal:
    Texture2dArrayRenderTargetView(D3D10_TEX2D_ARRAY_RTV* pTexture2dArrayRenderTargetView)
    {
        nativeObject.Set(pTexture2dArrayRenderTargetView);
    }
    Texture2dArrayRenderTargetView(D3D10_TEX2D_ARRAY_RTV* pTexture2dArrayRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTexture2dArrayRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of 2D textures to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_SRV)</para>
/// </summary>
public ref struct Texture2dArrayShaderResourceView 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_SRV.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of subtextures to access.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_SRV.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_SRV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures in the array.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_ARRAY_SRV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture2dArrayShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX2D_ARRAY_SRV());
    }
internal:
    AutoPointer<D3D10_TEX2D_ARRAY_SRV> nativeObject;
internal:
    Texture2dArrayShaderResourceView(D3D10_TEX2D_ARRAY_SRV* pTexture2dArrayShaderResourceView)
    {
        nativeObject.Set(pTexture2dArrayShaderResourceView);
    }
    Texture2dArrayShaderResourceView(D3D10_TEX2D_ARRAY_SRV* pTexture2dArrayShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTexture2dArrayShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a 2D texture that is accessable to a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_TEX2D_DSV)</para>
/// </summary>
public ref struct Texture2dDepthStencilView
{
public:
    /// <summary>
    /// The index of the first mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_DSV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
public:
    Texture2dDepthStencilView()
    {
        nativeObject.Set(new D3D10_TEX2D_DSV());
    }
internal:
    AutoPointer<D3D10_TEX2D_DSV> nativeObject;
internal:
    Texture2dDepthStencilView(D3D10_TEX2D_DSV* pTexture2dDepthStencilView)
    {
        nativeObject.Set(pTexture2dDepthStencilView);
    }
    Texture2dDepthStencilView(D3D10_TEX2D_DSV* pTexture2dDepthStencilView, bool deletable)
    {
        nativeObject.Set(pTexture2dDepthStencilView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a 2D texture to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX2D_RTV)</para>
/// </summary>
public ref struct Texture2dRenderTargetView 
{
public:
    /// <summary>
    /// The index of the mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_RTV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
public:
    Texture2dRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX2D_RTV());
    }
internal:
    AutoPointer<D3D10_TEX2D_RTV> nativeObject;
internal:
    Texture2dRenderTargetView(D3D10_TEX2D_RTV* pTexture2dRenderTargetView)
    {
        nativeObject.Set(pTexture2dRenderTargetView);
    }
    Texture2dRenderTargetView(D3D10_TEX2D_RTV* pTexture2dRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTexture2dRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a 2D texture to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX2D_SRV)</para>
/// </summary>
public ref struct Texture2dShaderResourceView 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_SRV.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of mipmap levels to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX2D_SRV.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
public:
    Texture2dShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX2D_SRV());
    }
internal:
    AutoPointer<D3D10_TEX2D_SRV> nativeObject;
internal:
    Texture2dShaderResourceView(D3D10_TEX2D_SRV* pTexture2dShaderResourceView)
    {
        nativeObject.Set(pTexture2dShaderResourceView);
    }
    Texture2dShaderResourceView(D3D10_TEX2D_SRV* pTexture2dShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTexture2dShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from a 3D texture to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX3D_RTV)</para>
/// </summary>
public ref struct Texture3dRenderTargetView 
{
public:
    /// <summary>
    /// The index of the mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX3D_RTV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
    /// <summary>
    /// First depth level to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX3D_RTV.FirstWSlice)</para>
    /// </summary>
    property UInt32 FirstWSlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstWSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstWSlice = value;
        }
    }
    /// <summary>
    /// Number of depth levels to use in the render-target view, starting from FirstWSlice. A value of -1 indicates all of the slices along the w axis, starting from FirstWSlice.
    /// <para>(Also see DirectX SDK: D3D10_TEX3D_RTV.WSize)</para>
    /// </summary>
    property UInt32 WSize
    {
        UInt32 get()
        {
            return (nativeObject->WSize);
        }
        void set(UInt32 value)
        {
            nativeObject->WSize = value;
        }
    }
public:
    Texture3dRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX3D_RTV());
    }
internal:
    AutoPointer<D3D10_TEX3D_RTV> nativeObject;
internal:
    Texture3dRenderTargetView(D3D10_TEX3D_RTV* pTex3dRenderTargetView)
    {
        nativeObject.Set(pTex3dRenderTargetView);
    }
    Texture3dRenderTargetView(D3D10_TEX3D_RTV* pTex3dRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTex3dRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from a 3D texture to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX3D_SRV)</para>
/// </summary>
public ref struct Texture3dShaderResourceView 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEX3D_SRV.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of mipmap levels to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX3D_SRV.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
public:
    Texture3dShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX3D_SRV());
    }
internal:
    AutoPointer<D3D10_TEX3D_SRV> nativeObject;
internal:
    Texture3dShaderResourceView(D3D10_TEX3D_SRV* pTex3dShaderResourceView)
    {
        nativeObject.Set(pTex3dShaderResourceView);
    }
    Texture3dShaderResourceView(D3D10_TEX3D_SRV* pTex3dShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTex3dShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of 1D textures to use in a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_DSV)</para>
/// </summary>
public ref struct Texture1dArrayDepthStencilView
{
public:
    /// <summary>
    /// The index of the first mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_DSV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_DSV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_DSV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture1dArrayDepthStencilView()
    {
        nativeObject.Set(new D3D10_TEX1D_ARRAY_DSV());
    }
internal:
    AutoPointer<D3D10_TEX1D_ARRAY_DSV> nativeObject;
internal:
    Texture1dArrayDepthStencilView(D3D10_TEX1D_ARRAY_DSV* pTexture1dArrayDepthStencilView)
    {
        nativeObject.Set(pTexture1dArrayDepthStencilView);
    }
    Texture1dArrayDepthStencilView(D3D10_TEX1D_ARRAY_DSV* pTexture1dArrayDepthStencilView, bool deletable)
    {
        nativeObject.Set(pTexture1dArrayDepthStencilView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of 1D textures to use in a render-target view.
/// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_RTV)</para>
/// </summary>
public ref struct Texture1dArrayRenderTargetView 
{
public:
    /// <summary>
    /// The index of the mipmap level to use (see mip slice).
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_RTV.MipSlice)</para>
    /// </summary>
    property UInt32 MipSlice
    {
        UInt32 get()
        {
            return (nativeObject->MipSlice);
        }
        void set(UInt32 value)
        {
            nativeObject->MipSlice = value;
        }
    }
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_RTV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures to use.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_RTV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture1dArrayRenderTargetView()
    {
        nativeObject.Set(new D3D10_TEX1D_ARRAY_RTV());
    }
internal:
    AutoPointer<D3D10_TEX1D_ARRAY_RTV> nativeObject;
internal:
    Texture1dArrayRenderTargetView(D3D10_TEX1D_ARRAY_RTV* pTexture1dArrayRenderTargetView)
    {
        nativeObject.Set(pTexture1dArrayRenderTargetView);
    }
    Texture1dArrayRenderTargetView(D3D10_TEX1D_ARRAY_RTV* pTexture1dArrayRenderTargetView, bool deletable)
    {
        nativeObject.Set(pTexture1dArrayRenderTargetView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of 1D textures to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_SRV)</para>
/// </summary>
public ref struct Texture1dArrayShaderResourceView 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_SRV.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of subtextures to access.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_SRV.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
    /// <summary>
    /// The index of the first texture to use in an array of textures (see array slice)
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_SRV.FirstArraySlice)</para>
    /// </summary>
    property UInt32 FirstArraySlice
    {
        UInt32 get()
        {
            return (nativeObject->FirstArraySlice);
        }
        void set(UInt32 value)
        {
            nativeObject->FirstArraySlice = value;
        }
    }
    /// <summary>
    /// Number of textures in the array.
    /// <para>(Also see DirectX SDK: D3D10_TEX1D_ARRAY_SRV.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
public:
    Texture1dArrayShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEX1D_ARRAY_SRV());
    }
internal:
    AutoPointer<D3D10_TEX1D_ARRAY_SRV> nativeObject;
internal:
    Texture1dArrayShaderResourceView(D3D10_TEX1D_ARRAY_SRV* pTexture1dArrayShaderResourceView)
    {
        nativeObject.Set(pTexture1dArrayShaderResourceView);
    }
    Texture1dArrayShaderResourceView(D3D10_TEX1D_ARRAY_SRV* pTexture1dArrayShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTexture1dArrayShaderResourceView, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from an array of cube textures to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEXCUBE_ARRAY_SRV1)</para>
/// </summary>
public ref struct TextureCubeArrayShaderResourceView1 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEXCUBE_ARRAY_SRV1.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of mipmap levels to use.
    /// <para>(Also see DirectX SDK: D3D10_TEXCUBE_ARRAY_SRV1.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
    /// <summary>
    /// Index of the first 2D texture to use.
    /// <para>(Also see DirectX SDK: D3D10_TEXCUBE_ARRAY_SRV1.First2DArrayFace)</para>
    /// </summary>
    property UInt32 First2DArrayFace
    {
        UInt32 get()
        {
            return (nativeObject->First2DArrayFace);
        }
        void set(UInt32 value)
        {
            nativeObject->First2DArrayFace = value;
        }
    }
    /// <summary>
    /// Number of cube textures in the array.
    /// <para>(Also see DirectX SDK: D3D10_TEXCUBE_ARRAY_SRV1.NumCubes)</para>
    /// </summary>
    property UInt32 NumCubes
    {
        UInt32 get()
        {
            return (nativeObject->NumCubes);
        }
        void set(UInt32 value)
        {
            nativeObject->NumCubes = value;
        }
    }
public:
    TextureCubeArrayShaderResourceView1()
    {
        nativeObject.Set(new D3D10_TEXCUBE_ARRAY_SRV1());
    }
internal:
    AutoPointer<D3D10_TEXCUBE_ARRAY_SRV1> nativeObject;
internal:
    TextureCubeArrayShaderResourceView1(D3D10_TEXCUBE_ARRAY_SRV1* pTextureCubeArrayShaderResourceView1)
    {
        nativeObject.Set(pTextureCubeArrayShaderResourceView1);
    }
    TextureCubeArrayShaderResourceView1(D3D10_TEXCUBE_ARRAY_SRV1* pTextureCubeArrayShaderResourceView1, bool deletable)
    {
        nativeObject.Set(pTextureCubeArrayShaderResourceView1, deletable);
    }
};
/// <summary>
/// Specifies the subresource from a cube texture to use in a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_TEXCUBE_SRV)</para>
/// </summary>
public ref struct TextureCubeShaderResourceView 
{
public:
    /// <summary>
    /// Index of the most detailed mipmap level to use; this number is between 0 and MipLevels.
    /// <para>(Also see DirectX SDK: D3D10_TEXCUBE_SRV.MostDetailedMip)</para>
    /// </summary>
    property UInt32 MostDetailedMip
    {
        UInt32 get()
        {
            return (nativeObject->MostDetailedMip);
        }
        void set(UInt32 value)
        {
            nativeObject->MostDetailedMip = value;
        }
    }
    /// <summary>
    /// Number of mipmap levels to use.
    /// <para>(Also see DirectX SDK: D3D10_TEXCUBE_SRV.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
public:
    TextureCubeShaderResourceView()
    {
        nativeObject.Set(new D3D10_TEXCUBE_SRV());
    }
internal:
    AutoPointer<D3D10_TEXCUBE_SRV> nativeObject;
internal:
    TextureCubeShaderResourceView(D3D10_TEXCUBE_SRV* pTextureCubeShaderResourceView)
    {
        nativeObject.Set(pTextureCubeShaderResourceView);
    }
    TextureCubeShaderResourceView(D3D10_TEXCUBE_SRV* pTextureCubeShaderResourceView, bool deletable)
    {
        nativeObject.Set(pTextureCubeShaderResourceView, deletable);
    }
};
/// <summary>
/// Describes a 1D texture.
/// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC)</para>
/// </summary>
public ref struct Texture1dDescription 
{
public:
    /// <summary>
    /// Texture width (in texels).
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.Width)</para>
    /// </summary>
    property UInt32 Width
    {
        UInt32 get()
        {
            return (nativeObject->Width);
        }
        void set(UInt32 value)
        {
            nativeObject->Width = value;
        }
    }
    /// <summary>
    /// Number of subtextures (also called mipmap levels). Use 1 for a multisampled texture; or 0 to generate a full set of subtextures.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
    /// <summary>
    /// Number of textures in the array.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
    /// <summary>
    /// Texture format (see <see cref="Format"/>)<seealso cref="Format"/>.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// Value that identifies how the texture is to be read from and written to. The most common value is Usage-DEFAULT; see Usage for all possible values.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.Usage)</para>
    /// </summary>
    property D3D10::Usage Usage
    {
        D3D10::Usage get()
        {
            return (D3D10::Usage)(nativeObject->Usage);
        }
        void set(D3D10::Usage value)
        {
            nativeObject->Usage = (D3D10_USAGE)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="BindFlag"/>)<seealso cref="BindFlag"/> for binding to pipeline stages. The flags can be combined by a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.BindFlags)</para>
    /// </summary>
    property BindFlag BindFlags
    {
        BindFlag get()
        {
            return (BindFlag)(nativeObject->BindFlags);
        }
        void set(BindFlag value)
        {
            nativeObject->BindFlags = (UINT)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="CpuAccessFlag"/>)<seealso cref="CpuAccessFlag"/> to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.CPUAccessFlags)</para>
    /// </summary>
    property CpuAccessFlag CPUAccessFlags
    {
        CpuAccessFlag get()
        {
            return (CpuAccessFlag)(nativeObject->CPUAccessFlags);
        }
        void set(CpuAccessFlag value)
        {
            nativeObject->CPUAccessFlags = (UINT) value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="ResourceMiscFlag"/>)<seealso cref="ResourceMiscFlag"/> that identifies other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE1D_DESC.MiscFlags)</para>
    /// </summary>
    property ResourceMiscFlag MiscFlags
    {
        ResourceMiscFlag get()
        {
            return (ResourceMiscFlag)(nativeObject->MiscFlags);
        }
        void set(ResourceMiscFlag value)
        {
            nativeObject->MiscFlags = (UINT)value;
        }
    }
public:
    Texture1dDescription()
    {
        nativeObject.Set(new D3D10_TEXTURE1D_DESC());
    }
internal:
    AutoPointer<D3D10_TEXTURE1D_DESC> nativeObject;
internal:
    Texture1dDescription(D3D10_TEXTURE1D_DESC* pTexture1dDescription)
    {
        nativeObject.Set(pTexture1dDescription);
    }
    Texture1dDescription(D3D10_TEXTURE1D_DESC* pTexture1dDescription, bool deletable)
    {
        nativeObject.Set(pTexture1dDescription, deletable);
    }
};
/// <summary>
/// Describes a 2D texture.
/// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC)</para>
/// </summary>
public ref struct Texture2dDescription 
{
public:
    /// <summary>
    /// Texture width (in texels). See Remarks.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.Width)</para>
    /// </summary>
    property UInt32 Width
    {
        UInt32 get()
        {
            return (nativeObject->Width);
        }
        void set(UInt32 value)
        {
            nativeObject->Width = value;
        }
    }
    /// <summary>
    /// Texture height (in texels). See Remarks.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.Height)</para>
    /// </summary>
    property UInt32 Height
    {
        UInt32 get()
        {
            return (nativeObject->Height);
        }
        void set(UInt32 value)
        {
            nativeObject->Height = value;
        }
    }
    /// <summary>
    /// Number of subtextures (also called mipmap levels). Use 1 for a multisampled texture; or 0 to generate a full set of subtextures.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
    /// <summary>
    /// Number of textures in the texture array.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.ArraySize)</para>
    /// </summary>
    property UInt32 ArraySize
    {
        UInt32 get()
        {
            return (nativeObject->ArraySize);
        }
        void set(UInt32 value)
        {
            nativeObject->ArraySize = value;
        }
    }
    /// <summary>
    ///  format (see <see cref="Format"/>)<seealso cref="Format"/>.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// Structure that specifies multisampling parameters for the texture. See SampleDescription.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.SampleDesc)</para>
    /// </summary>
    property DXGI::SampleDescription^ SampleDescription
    {
        DXGI::SampleDescription^ get()
        {
            if (sampleDesc == nullptr)
                sampleDesc = gcnew DXGI::SampleDescription(&(nativeObject->SampleDesc), false);
            return sampleDesc;
        }
        void set(DXGI::SampleDescription^ value)
        {
            memcpy(&(nativeObject->SampleDesc), (void*)(value->nativeObject.Get()), sizeof(DXGI_SAMPLE_DESC));
        }
    }
    /// <summary>
    /// Value that identifies how the texture is to be read from and written to. The most common value is Usage-DEFAULT; see Usage for all possible values.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.Usage)</para>
    /// </summary>
    property D3D10::Usage Usage
    {
        D3D10::Usage get()
        {
            return (D3D10::Usage)(nativeObject->Usage);
        }
        void set(D3D10::Usage value)
        {
            nativeObject->Usage = (D3D10_USAGE)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="BindFlag"/>)<seealso cref="BindFlag"/> for binding to pipeline stages. The flags can be combined by a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.BindFlags)</para>
    /// </summary>
    property BindFlag BindFlags
    {
        BindFlag get()
        {
            return (BindFlag)(nativeObject->BindFlags);
        }
        void set(BindFlag value)
        {
            nativeObject->BindFlags = (UINT)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="CpuAccessFlag"/>)<seealso cref="CpuAccessFlag"/> to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.CPUAccessFlags)</para>
    /// </summary>
    property CpuAccessFlag CPUAccessFlags
    {
        CpuAccessFlag get()
        {
            return (CpuAccessFlag)(nativeObject->CPUAccessFlags);
        }
        void set(CpuAccessFlag value)
        {
            nativeObject->CPUAccessFlags = (UINT)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="ResourceMiscFlag"/>)<seealso cref="ResourceMiscFlag"/> that identifies other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE2D_DESC.MiscFlags)</para>
    /// </summary>
    property ResourceMiscFlag MiscFlags
    {
        ResourceMiscFlag get()
        {
            return (ResourceMiscFlag)(nativeObject->MiscFlags);
        }
        void set(ResourceMiscFlag value)
        {
            nativeObject->MiscFlags = (UINT)value;
        }
    }
public:
    Texture2dDescription()
    {
        nativeObject.Set(new D3D10_TEXTURE2D_DESC());
    }
internal:
    AutoPointer<D3D10_TEXTURE2D_DESC> nativeObject;
internal:
    Texture2dDescription(D3D10_TEXTURE2D_DESC* pTexture2dDescription)
    {
        nativeObject.Set(pTexture2dDescription);
    }
    Texture2dDescription(D3D10_TEXTURE2D_DESC* pTexture2dDescription, bool deletable)
    {
        nativeObject.Set(pTexture2dDescription, deletable);
    }
    DXGI::SampleDescription^ sampleDesc;
};
/// <summary>
/// Describes a 3D texture.
/// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC)</para>
/// </summary>
public ref struct Texture3dDescription 
{
public:
    /// <summary>
    /// Texture width (in texels). See Remarks.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.Width)</para>
    /// </summary>
    property UInt32 Width
    {
        UInt32 get()
        {
            return (nativeObject->Width);
        }
        void set(UInt32 value)
        {
            nativeObject->Width = value;
        }
    }
    /// <summary>
    /// Texture height (in texels). See Remarks.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.Height)</para>
    /// </summary>
    property UInt32 Height
    {
        UInt32 get()
        {
            return (nativeObject->Height);
        }
        void set(UInt32 value)
        {
            nativeObject->Height = value;
        }
    }
    /// <summary>
    /// Texture depth (in texels)
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.Depth)</para>
    /// </summary>
    property UInt32 Depth
    {
        UInt32 get()
        {
            return (nativeObject->Depth);
        }
        void set(UInt32 value)
        {
            nativeObject->Depth = value;
        }
    }
    /// <summary>
    /// Number of subtextures (also called mipmap levels). Use 1 for a multisampled texture; or 0 to generate a full set of subtextures.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.MipLevels)</para>
    /// </summary>
    property UInt32 MipLevels
    {
        UInt32 get()
        {
            return (nativeObject->MipLevels);
        }
        void set(UInt32 value)
        {
            nativeObject->MipLevels = value;
        }
    }
    /// <summary>
    ///  format (see <see cref="Format"/>)<seealso cref="Format"/>.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// Value that identifies how the texture is to be read from and written to. The most common value is Usage-DEFAULT; see Usage for all possible values.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.Usage)</para>
    /// </summary>
    property D3D10::Usage Usage
    {
        D3D10::Usage get()
        {
            return (D3D10::Usage)(nativeObject->Usage);
        }
        void set(D3D10::Usage value)
        {
            nativeObject->Usage = (D3D10_USAGE)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="BindFlag"/>)<seealso cref="BindFlag"/> for binding to pipeline stages. The flags can be combined by a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.BindFlags)</para>
    /// </summary>
    property BindFlag BindFlags
    {
        BindFlag get()
        {
            return (BindFlag)(nativeObject->BindFlags);
        }
        void set(BindFlag value)
        {
            nativeObject->BindFlags = (UINT) value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="CpuAccessFlag"/>)<seealso cref="CpuAccessFlag"/> to specify the types of CPU access allowed. Use 0 if CPU access is not required. These flags can be combined with a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.CPUAccessFlags)</para>
    /// </summary>
    property CpuAccessFlag CPUAccessFlags
    {
        CpuAccessFlag get()
        {
            return (CpuAccessFlag)(nativeObject->CPUAccessFlags);
        }
        void set(CpuAccessFlag value)
        {
            nativeObject->CPUAccessFlags = (UINT)value;
        }
    }
    /// <summary>
    /// Flags (see <see cref="ResourceMiscFlag"/>)<seealso cref="ResourceMiscFlag"/> that identifies other, less common resource options. Use 0 if none of these flags apply. These flags can be combined with a logical OR.
    /// <para>(Also see DirectX SDK: D3D10_TEXTURE3D_DESC.MiscFlags)</para>
    /// </summary>
    property ResourceMiscFlag MiscFlags
    {
        ResourceMiscFlag get()
        {
            return (ResourceMiscFlag)(nativeObject->MiscFlags);
        }
        void set(ResourceMiscFlag value)
        {
            nativeObject->MiscFlags = (UINT)value;
        }
    }
public:
    Texture3dDescription()
    {
        nativeObject.Set(new D3D10_TEXTURE3D_DESC());
    }
internal:
    AutoPointer<D3D10_TEXTURE3D_DESC> nativeObject;
internal:
    Texture3dDescription(D3D10_TEXTURE3D_DESC* pTexture3dDescription)
    {
        nativeObject.Set(pTexture3dDescription);
    }
    Texture3dDescription(D3D10_TEXTURE3D_DESC* pTexture3dDescription, bool deletable)
    {
        nativeObject.Set(pTexture3dDescription, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from a texture that are accessible using a depth-stencil view.
/// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC)</para>
/// </summary>
public ref struct DepthStencilViewDescription 
{
public:
    /// <summary>
    ///   format (see <see cref="Format"/>)<seealso cref="Format"/>. See remarks for allowable formats.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// Type of resource (see <see cref="DepthStencilViewDimension"/>)<seealso cref="DepthStencilViewDimension"/>. Specifies how a depth-stencil resource will be accessed; the value is stored in the union in this structure.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.ViewDimension)</para>
    /// </summary>
    property DepthStencilViewDimension ViewDimension
    {
        DepthStencilViewDimension get()
        {
            return (DepthStencilViewDimension)(nativeObject->ViewDimension);
        }
        void set(DepthStencilViewDimension value)
        {
            nativeObject->ViewDimension = (D3D10_DSV_DIMENSION)value;
        }
    }

    /// <summary>
    /// Specifies a 1D texture subresource (see <see cref="Texture1dDepthStencilView"/>)<seealso cref="Texture1dDepthStencilView"/>.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Texture1D)</para>
    /// </summary>
    property Texture1dDepthStencilView^ Texture1d
    {
        Texture1dDepthStencilView^ get()
        {
            return gcnew Texture1dDepthStencilView(&(nativeObject->Texture1D), false);
        }
        void set(Texture1dDepthStencilView^ value)
        {
            memcpy(&(nativeObject->Texture1D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_DSV));
        }
    }
    /// <summary>
    /// Specifies an array of 1D texture subresources (see <see cref="Texture1dArrayDepthStencilView"/>)<seealso cref="Texture1dArrayDepthStencilView"/>.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Texture1dArray)</para>
    /// </summary>
    property Texture1dArrayDepthStencilView^ Texture1dArray
    {
        Texture1dArrayDepthStencilView^ get()
        {
            return gcnew Texture1dArrayDepthStencilView(&(nativeObject->Texture1DArray), false);
        }
        void set(Texture1dArrayDepthStencilView^ value)
        {
            memcpy(&(nativeObject->Texture1DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_ARRAY_DSV));
        }
    }
    /// <summary>
    /// Specifies a 2D texture subresource (see <see cref="Texture2dDepthStencilView"/>)<seealso cref="Texture2dDepthStencilView"/>.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Texture2D)</para>
    /// </summary>
    property Texture2dDepthStencilView^ Texture2d
    {
        Texture2dDepthStencilView^ get()
        {
            return gcnew Texture2dDepthStencilView(&(nativeObject->Texture2D), false);
        }
        void set(Texture2dDepthStencilView^ value)
        {
            memcpy(&(nativeObject->Texture2D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_DSV));
        }
    }
    /// <summary>
    /// Specifies an array of 2D texture subresources (see <see cref="Texture2dArrayDepthStencilView"/>)<seealso cref="Texture2dArrayDepthStencilView"/>.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Texture2dArray)</para>
    /// </summary>
    property Texture2dArrayDepthStencilView^ Texture2dArray
    {
        Texture2dArrayDepthStencilView^ get()
        {
            return gcnew Texture2dArrayDepthStencilView(&(nativeObject->Texture2DArray), false);
        }
        void set(Texture2dArrayDepthStencilView^ value)
        {
            memcpy(&(nativeObject->Texture2DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_ARRAY_DSV));
        }
    }
    /// <summary>
    /// Unused -- a multisampled 2D texture contains a single subresource.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Texture2dMultiSample)</para>
    /// </summary>
    property Texture2dMultiSampleDepthStencilView^ Texture2dMultiSample
    {
        Texture2dMultiSampleDepthStencilView^ get()
        {
            return gcnew Texture2dMultiSampleDepthStencilView(&(nativeObject->Texture2DMS), false);
        }
        void set(Texture2dMultiSampleDepthStencilView^ value)
        {
            memcpy(&(nativeObject->Texture2DMS), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_DSV));
        }
    }
    /// <summary>
    /// Unused -- a multisampled 2D texture contains a single subresource per texture.
    /// <para>(Also see DirectX SDK: D3D10_DEPTH_STENCIL_VIEW_DESC.Texture2DMSArray)</para>
    /// </summary>
    property Texture2dMultiSampleArrayDepthStencilView^ Texture2dMSArray
    {
        Texture2dMultiSampleArrayDepthStencilView^ get()
        {
            return gcnew Texture2dMultiSampleArrayDepthStencilView(&(nativeObject->Texture2DMSArray), false);
        }
        void set(Texture2dMultiSampleArrayDepthStencilView^ value)
        {
            memcpy(&(nativeObject->Texture2DMSArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_ARRAY_DSV));
        }
    }

public:
    DepthStencilViewDescription()
    {
        nativeObject.Set(new D3D10_DEPTH_STENCIL_VIEW_DESC());
    }
internal:
    AutoPointer<D3D10_DEPTH_STENCIL_VIEW_DESC> nativeObject;
internal:
    DepthStencilViewDescription(D3D10_DEPTH_STENCIL_VIEW_DESC* pDepthStencilViewDescription)
    {
        nativeObject.Set(pDepthStencilViewDescription);
    }
    DepthStencilViewDescription(D3D10_DEPTH_STENCIL_VIEW_DESC* pDepthStencilViewDescription, bool deletable)
    {
        nativeObject.Set(pDepthStencilViewDescription, deletable);
    }
};
/// <summary>
/// Describes an effect.
/// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC)</para>
/// </summary>
public ref struct EffectDescription 
{
public:
    /// <summary>
    /// TRUE if the effect is a child effect; otherwise FALSE.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC.IsChildEffect)</para>
    /// </summary>
    property Boolean IsChildEffect
    {
        Boolean get()
        {
            return nativeObject->IsChildEffect != 0;
        }
        void set(Boolean value)
        {
            nativeObject->IsChildEffect = (BOOL)value;
        }
    }
    /// <summary>
    /// The number of constant buffers.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC.ConstantBuffers)</para>
    /// </summary>
    property UInt32 ConstantBuffers
    {
        UInt32 get()
        {
            return (nativeObject->ConstantBuffers);
        }
        void set(UInt32 value)
        {
            nativeObject->ConstantBuffers = value;
        }
    }
    /// <summary>
    /// The number of constant buffers shared in an effect pool.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC.SharedConstantBuffers)</para>
    /// </summary>
    property UInt32 SharedConstantBuffers
    {
        UInt32 get()
        {
            return (nativeObject->SharedConstantBuffers);
        }
        void set(UInt32 value)
        {
            nativeObject->SharedConstantBuffers = value;
        }
    }
    /// <summary>
    /// The number of global variables.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC.GlobalVariables)</para>
    /// </summary>
    property UInt32 GlobalVariables
    {
        UInt32 get()
        {
            return (nativeObject->GlobalVariables);
        }
        void set(UInt32 value)
        {
            nativeObject->GlobalVariables = value;
        }
    }
    /// <summary>
    /// The number of global variables shared in an effect pool.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC.SharedGlobalVariables)</para>
    /// </summary>
    property UInt32 SharedGlobalVariables
    {
        UInt32 get()
        {
            return (nativeObject->SharedGlobalVariables);
        }
        void set(UInt32 value)
        {
            nativeObject->SharedGlobalVariables = value;
        }
    }
    /// <summary>
    /// The number of techniques.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_DESC.Techniques)</para>
    /// </summary>
    property UInt32 Techniques
    {
        UInt32 get()
        {
            return (nativeObject->Techniques);
        }
        void set(UInt32 value)
        {
            nativeObject->Techniques = value;
        }
    }
public:
    EffectDescription()
    {
        nativeObject.Set(new D3D10_EFFECT_DESC());
    }
internal:
    AutoPointer<D3D10_EFFECT_DESC> nativeObject;
internal:
    EffectDescription(D3D10_EFFECT_DESC* pEffectDescription)
    {
        nativeObject.Set(pEffectDescription);
    }
    EffectDescription(D3D10_EFFECT_DESC* pEffectDescription, bool deletable)
    {
        nativeObject.Set(pEffectDescription, deletable);
    }
};
/// <summary>
/// Describes an effect shader.
/// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC)</para>
/// </summary>
public ref struct EffectShaderDescription 
{
public:
    /// <summary>
    /// Passed into CreateInputLayout. Only valid on a vertex shader or geometry shader. See ID3D10Device_CreateInputLayout.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.pInputSignature)</para>
    /// </summary>
    property IntPtr pInputSignature
    {
        IntPtr get()
        {
            return IntPtr((void*)nativeObject->pInputSignature);
        }

        void set(IntPtr value)
        {
            nativeObject->pInputSignature = (BYTE*) value.ToPointer();
        }
    }

    /// <summary>
    /// TRUE is the shader is defined inline; otherwise FALSE.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.IsInline)</para>
    /// </summary>
    property Boolean IsInline
    {
        Boolean get()
        {
            return nativeObject->IsInline != 0;
        }
        void set(Boolean value)
        {
            nativeObject->IsInline = (BOOL)value;
        }
    }
    /// <summary>
    /// The compiled shader.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.pBytecode)</para>
    /// </summary>
    property IntPtr pBytecode
    {
        IntPtr get()
        {
            return IntPtr((void*)nativeObject->pBytecode);
        }

        void set(IntPtr value)
        {
            nativeObject->pBytecode = (BYTE*) value.ToPointer();
        }
    }

    /// <summary>
    /// The length of pBytecode.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.BytecodeLength)</para>
    /// </summary>
    property UInt32 BytecodeLength
    {
        UInt32 get()
        {
            return (nativeObject->BytecodeLength);
        }
        void set(UInt32 value)
        {
            nativeObject->BytecodeLength = value;
        }
    }
    /// <summary>
    /// A string that constains a declaration of the stream output  from a geometry shader.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.SODecl)</para>
    /// </summary>
    property String^ SODecl
    {
        String^ get()
        {
            if (nativeObject->SODecl == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->SODecl);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("SODecl", "SODecl cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->SODecl = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The number of entries in the input signature.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.NumInputSignatureEntries)</para>
    /// </summary>
    property UInt32 NumInputSignatureEntries
    {
        UInt32 get()
        {
            return (nativeObject->NumInputSignatureEntries);
        }
        void set(UInt32 value)
        {
            nativeObject->NumInputSignatureEntries = value;
        }
    }
    /// <summary>
    /// The number of entries in the output signature.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_SHADER_DESC.NumOutputSignatureEntries)</para>
    /// </summary>
    property UInt32 NumOutputSignatureEntries
    {
        UInt32 get()
        {
            return (nativeObject->NumOutputSignatureEntries);
        }
        void set(UInt32 value)
        {
            nativeObject->NumOutputSignatureEntries = value;
        }
    }
public:
    EffectShaderDescription()
    {
        nativeObject.Set(new D3D10_EFFECT_SHADER_DESC());
    }
internal:
    AutoPointer<D3D10_EFFECT_SHADER_DESC> nativeObject;
internal:
    EffectShaderDescription(D3D10_EFFECT_SHADER_DESC* pEffectShaderDescription)
    {
        nativeObject.Set(pEffectShaderDescription);
    }
    EffectShaderDescription(D3D10_EFFECT_SHADER_DESC* pEffectShaderDescription, bool deletable)
    {
        nativeObject.Set(pEffectShaderDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Describes an effect-variable type.
/// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC)</para>
/// </summary>
public ref struct EffectTypeDescription 
{
public:
    /// <summary>
    /// A string that contains the variable name.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.TypeName)</para>
    /// </summary>
    property String^ TypeName
    {
        String^ get()
        {
            if (nativeObject->TypeName == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->TypeName);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("TypeName", "TypeName cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->TypeName = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The variable class (see <see cref="ShaderVariableClass"/>)<seealso cref="ShaderVariableClass"/>.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Class)</para>
    /// </summary>
    property ShaderVariableClass Class
    {
        ShaderVariableClass get()
        {
            return (ShaderVariableClass)(nativeObject->Class);
        }
        void set(ShaderVariableClass value)
        {
            nativeObject->Class = (D3D10_SHADER_VARIABLE_CLASS)value;
        }
    }
    /// <summary>
    /// The variable type (see <see cref="ShaderVariableType"/>)<seealso cref="ShaderVariableType"/>.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Type)</para>
    /// </summary>
    property ShaderVariableType Type
    {
        ShaderVariableType get()
        {
            return (ShaderVariableType)(nativeObject->Type);
        }
        void set(ShaderVariableType value)
        {
            nativeObject->Type = (D3D10_SHADER_VARIABLE_TYPE)value;
        }
    }
    /// <summary>
    /// The number of elements if the variable is an array; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Elements)</para>
    /// </summary>
    property UInt32 Elements
    {
        UInt32 get()
        {
            return (nativeObject->Elements);
        }
        void set(UInt32 value)
        {
            nativeObject->Elements = value;
        }
    }
    /// <summary>
    /// The number of members if the variable is a structure; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Members)</para>
    /// </summary>
    property UInt32 Members
    {
        UInt32 get()
        {
            return (nativeObject->Members);
        }
        void set(UInt32 value)
        {
            nativeObject->Members = value;
        }
    }
    /// <summary>
    /// The number of rows if the variable is a matrix; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Rows)</para>
    /// </summary>
    property UInt32 Rows
    {
        UInt32 get()
        {
            return (nativeObject->Rows);
        }
        void set(UInt32 value)
        {
            nativeObject->Rows = value;
        }
    }
    /// <summary>
    /// The number of columns if the variable is a matrix; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Columns)</para>
    /// </summary>
    property UInt32 Columns
    {
        UInt32 get()
        {
            return (nativeObject->Columns);
        }
        void set(UInt32 value)
        {
            nativeObject->Columns = value;
        }
    }
    /// <summary>
    /// The number of bytes that the variable consumes when it is packed tightly by the compiler.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.PackedSize)</para>
    /// </summary>
    property UInt32 PackedSize
    {
        UInt32 get()
        {
            return (nativeObject->PackedSize);
        }
        void set(UInt32 value)
        {
            nativeObject->PackedSize = value;
        }
    }
    /// <summary>
    /// The number of bytes that the variable consumes before it is packed by the compiler.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.UnpackedSize)</para>
    /// </summary>
    property UInt32 UnpackedSize
    {
        UInt32 get()
        {
            return (nativeObject->UnpackedSize);
        }
        void set(UInt32 value)
        {
            nativeObject->UnpackedSize = value;
        }
    }
    /// <summary>
    /// The number of bytes between elements.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_TYPE_DESC.Stride)</para>
    /// </summary>
    property UInt32 Stride
    {
        UInt32 get()
        {
            return (nativeObject->Stride);
        }
        void set(UInt32 value)
        {
            nativeObject->Stride = value;
        }
    }
public:
    EffectTypeDescription()
    {
        nativeObject.Set(new D3D10_EFFECT_TYPE_DESC());
    }
internal:
    AutoPointer<D3D10_EFFECT_TYPE_DESC> nativeObject;
internal:
    EffectTypeDescription(D3D10_EFFECT_TYPE_DESC* pEffectTypeDescription)
    {
        nativeObject.Set(pEffectTypeDescription);
    }
    EffectTypeDescription(D3D10_EFFECT_TYPE_DESC* pEffectTypeDescription, bool deletable)
    {
        nativeObject.Set(pEffectTypeDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Describes an effect variable.
/// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC)</para>
/// </summary>
public ref struct EffectVariableDescription 
{
public:
    /// <summary>
    /// A string that contains the variable name.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The semantic attached to the variable; otherwise NULL.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC.Semantic)</para>
    /// </summary>
    property String^ Semantic
    {
        String^ get()
        {
            if (nativeObject->Semantic == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Semantic);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Semantic", "Semantic cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Semantic = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// Optional flags for effect variables.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC.Flags)</para>
    /// </summary>
    property UInt32 Flags
    {
        UInt32 get()
        {
            return (nativeObject->Flags);
        }
        void set(UInt32 value)
        {
            nativeObject->Flags = value;
        }
    }
    /// <summary>
    /// The number of annotations; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC.Annotations)</para>
    /// </summary>
    property UInt32 Annotations
    {
        UInt32 get()
        {
            return (nativeObject->Annotations);
        }
        void set(UInt32 value)
        {
            nativeObject->Annotations = value;
        }
    }
    /// <summary>
    /// The offset between the begining of the constant buffer and this variable; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC.BufferOffset)</para>
    /// </summary>
    property UInt32 BufferOffset
    {
        UInt32 get()
        {
            return (nativeObject->BufferOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->BufferOffset = value;
        }
    }
    /// <summary>
    /// The register that this variable is bound to. To bind a variable explicitly use the D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT flag.
    /// <para>(Also see DirectX SDK: D3D10_EFFECT_VARIABLE_DESC.ExplicitBindPoint)</para>
    /// </summary>
    property UInt32 ExplicitBindPoint
    {
        UInt32 get()
        {
            return (nativeObject->ExplicitBindPoint);
        }
        void set(UInt32 value)
        {
            nativeObject->ExplicitBindPoint = value;
        }
    }
public:
    EffectVariableDescription()
    {
        nativeObject.Set(new D3D10_EFFECT_VARIABLE_DESC());
    }
internal:
    AutoPointer<D3D10_EFFECT_VARIABLE_DESC> nativeObject;
internal:
    EffectVariableDescription(D3D10_EFFECT_VARIABLE_DESC* pEffectVariableDescription)
    {
        nativeObject.Set(pEffectVariableDescription);
    }
    EffectVariableDescription(D3D10_EFFECT_VARIABLE_DESC* pEffectVariableDescription, bool deletable)
    {
        nativeObject.Set(pEffectVariableDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Allow or deny certain types of messages to pass through a filter.
/// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC)</para>
/// </summary>
public ref struct InfoQueueFilterDescription 
{
public:
    /// <summary>
    /// Number of message categories to allow or deny.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC.NumCategories)</para>
    /// </summary>
    property UInt32 NumCategories
    {
        UInt32 get()
        {
            return (nativeObject->NumCategories);
        }
        void set(UInt32 value)
        {
            nativeObject->NumCategories = value;
        }
    }
    /// <summary>
    /// Array of message categories to allow or deny. Array must have at least NumCategories members (see <see cref="MessageCategory"/>)<seealso cref="MessageCategory"/>.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC.pCategoryList)</para>
    /// </summary>
    property Object^ pCategoryList
    {
        Object^ get()
        {
    //        return (Object^)(nativeObject->pCategoryList);
            return nullptr;
        }
        void set(Object^ value)
        {
    //        nativeObject->pCategoryList = (D3D10_MESSAGE_CATEGORY)value;
        }
    }
    /// <summary>
    /// Number of message severity levels to allow or deny.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC.NumSeverities)</para>
    /// </summary>
    property UInt32 NumSeverities
    {
        UInt32 get()
        {
            return (nativeObject->NumSeverities);
        }
        void set(UInt32 value)
        {
            nativeObject->NumSeverities = value;
        }
    }
    /// <summary>
    /// Array of message severity levels to allow or deny. Array must have at least NumSeverities members (see <see cref="MessageSeverity"/>)<seealso cref="MessageSeverity"/>.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC.pSeverityList)</para>
    /// </summary>
    property Object^ pSeverityList
    {
        Object^ get()
        {
    //        return (Object^)(nativeObject->pSeverityList);
            return nullptr;
        }
        void set(Object^ value)
        {
    //        nativeObject->pSeverityList = (D3D10_MESSAGE_SEVERITY)value;
        }
    }
    /// <summary>
    /// Number of message IDs to allow or deny.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC.NumIDs)</para>
    /// </summary>
    property UInt32 NumIDs
    {
        UInt32 get()
        {
            return (nativeObject->NumIDs);
        }
        void set(UInt32 value)
        {
            nativeObject->NumIDs = value;
        }
    }
    /// <summary>
    /// Array of message IDs to allow or deny. Array must have at least NumIDs members (see <see cref="MessageId"/>)<seealso cref="MessageId"/>.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER_DESC.pIDList)</para>
    /// </summary>
    property Object^ pIDList
    {
        Object^ get()
        {
    //        return (Object^)(nativeObject->pIDList);
            return nullptr;
        }
        void set(Object^ value)
        {
    //        nativeObject->pIDList = (D3D10_MESSAGE_ID)value;
        }
    }
public:
    InfoQueueFilterDescription()
    {
        nativeObject.Set(new D3D10_INFO_QUEUE_FILTER_DESC());
    }
internal:
    AutoPointer<D3D10_INFO_QUEUE_FILTER_DESC> nativeObject;
internal:
    InfoQueueFilterDescription(D3D10_INFO_QUEUE_FILTER_DESC* pInfoQueueFilterDescription)
    {
        nativeObject.Set(pInfoQueueFilterDescription);
    }
    InfoQueueFilterDescription(D3D10_INFO_QUEUE_FILTER_DESC* pInfoQueueFilterDescription, bool deletable)
    {
        nativeObject.Set(pInfoQueueFilterDescription, deletable);
    }
};
/// <summary>
/// Debug message filter; contains a lists of message types to allow or deny.
/// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER)</para>
/// </summary>
public ref struct InfoQueueFilter 
{
public:
    /// <summary>
    /// A InfoQueueFilterDescription structure describing the types of messages the info queue should allow.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER.AllowList)</para>
    /// </summary>
    property InfoQueueFilterDescription^ AllowList
    {
        InfoQueueFilterDescription^ get()
        {
            return gcnew InfoQueueFilterDescription(&(nativeObject->AllowList), false);
        }
        void set(InfoQueueFilterDescription^ value)
        {
            memcpy(&(nativeObject->AllowList), (void*)(value->nativeObject.Get()), sizeof(D3D10_INFO_QUEUE_FILTER_DESC));
        }
    }
    /// <summary>
    /// A InfoQueueFilterDescription structure describing the types of messages the info queue should reject.
    /// <para>(Also see DirectX SDK: D3D10_INFO_QUEUE_FILTER.DenyList)</para>
    /// </summary>
    property InfoQueueFilterDescription^ DenyList
    {
        InfoQueueFilterDescription^ get()
        {
            return gcnew InfoQueueFilterDescription(&(nativeObject->DenyList), false);
        }
        void set(InfoQueueFilterDescription^ value)
        {
            memcpy(&(nativeObject->DenyList), (void*)(value->nativeObject.Get()), sizeof(D3D10_INFO_QUEUE_FILTER_DESC));
        }
    }
public:
    InfoQueueFilter()
    {
        nativeObject.Set(new D3D10_INFO_QUEUE_FILTER());
    }
internal:
    AutoPointer<D3D10_INFO_QUEUE_FILTER> nativeObject;
internal:
    InfoQueueFilter(D3D10_INFO_QUEUE_FILTER* pInfoQueueFilter)
    {
        nativeObject.Set(pInfoQueueFilter);
    }
    InfoQueueFilter(D3D10_INFO_QUEUE_FILTER* pInfoQueueFilter, bool deletable)
    {
        nativeObject.Set(pInfoQueueFilter, deletable);
    }
};
/// <summary>
/// A description of a single element for the input-assembler stage.
/// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC)</para>
/// </summary>
public ref struct InputElementDescription 
{
public:
    /// <summary>
    /// The HLSL semantic associated with this element in a shader input-signature.
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.SemanticName)</para>
    /// </summary>
    property String^ SemanticName
    {
        String^ get()
        {
            if (nativeObject->SemanticName == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->SemanticName);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("SemanticName", "SemanticName cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->SemanticName = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix, however each of the four component would have different semantic indices (0, 1, 2, and 3).
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.SemanticIndex)</para>
    /// </summary>
    property UInt32 SemanticIndex
    {
        UInt32 get()
        {
            return (nativeObject->SemanticIndex);
        }
        void set(UInt32 value)
        {
            nativeObject->SemanticIndex = value;
        }
    }
    /// <summary>
    /// The data type of the element data. See Format.
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// An integer value that identifies the input-assembler (see input slot). Valid values are between 0 and 15, defined in D3D10.h.
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.InputSlot)</para>
    /// </summary>
    property UInt32 InputSlot
    {
        UInt32 get()
        {
            return (nativeObject->InputSlot);
        }
        void set(UInt32 value)
        {
            nativeObject->InputSlot = value;
        }
    }
    /// <summary>
    /// Optional. Offset (in bytes) between each element. Use D3D10_APPEND_ALIGNED_ELEMENT for convenience to define the current element directly after the previous one, including any packing if necessary.
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.AlignedByteOffset)</para>
    /// </summary>
    property UInt32 AlignedByteOffset
    {
        UInt32 get()
        {
            return (nativeObject->AlignedByteOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->AlignedByteOffset = value;
        }
    }
    /// <summary>
    /// Identifies the input data class for a single input slot (see <see cref="InputClassification"/>)<seealso cref="InputClassification"/>.
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.InputSlotClass)</para>
    /// </summary>
    property InputClassification InputSlotClass
    {
        InputClassification get()
        {
            return (InputClassification)(nativeObject->InputSlotClass);
        }
        void set(InputClassification value)
        {
            nativeObject->InputSlotClass = (D3D10_INPUT_CLASSIFICATION)value;
        }
    }
    /// <summary>
    /// The number of instances to draw before stepping one unit forward in a vertex buffer filled with instance data. Can be any unsigned integer value (0 means do not step) when the slot class is D3D10_INPUT_PER_INSTANCE_DATA; must be 0 when the slot class is PerVertexData.
    /// <para>(Also see DirectX SDK: D3D10_INPUT_ELEMENT_DESC.InstanceDataStepRate)</para>
    /// </summary>
    property UInt32 InstanceDataStepRate
    {
        UInt32 get()
        {
            return (nativeObject->InstanceDataStepRate);
        }
        void set(UInt32 value)
        {
            nativeObject->InstanceDataStepRate = value;
        }
    }
public:
    InputElementDescription()
    {
        nativeObject.Set(new D3D10_INPUT_ELEMENT_DESC());
        ZeroMemory(nativeObject.Get(), sizeof(D3D10_INPUT_ELEMENT_DESC));
    }
internal:
    AutoPointer<D3D10_INPUT_ELEMENT_DESC> nativeObject;
internal:
    InputElementDescription(D3D10_INPUT_ELEMENT_DESC* pInputElementDescription)
    {
        nativeObject.Set(pInputElementDescription);
    }
    InputElementDescription(D3D10_INPUT_ELEMENT_DESC* pInputElementDescription, bool deletable)
    {
        nativeObject.Set(pInputElementDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Provides access to subresource data in a 2D texture.
/// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE2D)</para>
/// </summary>
public ref struct MappedTexture2d 
{
public:
    /// <summary>
    /// Pointer to the data.
    /// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE2D.pData)</para>
    /// </summary>
    property IntPtr pData
    {
        IntPtr get()
        {
            return IntPtr(nativeObject->pData);
        }

        void set(IntPtr value)
        {
            nativeObject->pData = value.ToPointer();
        }
    }

    /// <summary>
    /// The pitch, or width, or physical size (in bytes), of one row of an uncompressed texture. A block-compressed texture is encoded in 4x4 blocks (see virtual size vs physical size) ; therefore, RowPitch is the number of bytes in a block of 4x4 texels.
    /// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE2D.RowPitch)</para>
    /// </summary>
    property UInt32 RowPitch
    {
        UInt32 get()
        {
            return (nativeObject->RowPitch);
        }
        void set(UInt32 value)
        {
            nativeObject->RowPitch = value;
        }
    }
public:
    MappedTexture2d()
    {
        nativeObject.Set(new D3D10_MAPPED_TEXTURE2D());
    }
internal:
    AutoPointer<D3D10_MAPPED_TEXTURE2D> nativeObject;
internal:
    MappedTexture2d(D3D10_MAPPED_TEXTURE2D* pMappedTexture2d)
    {
        nativeObject.Set(pMappedTexture2d);
    }
    MappedTexture2d(D3D10_MAPPED_TEXTURE2D* pMappedTexture2d, bool deletable)
    {
        nativeObject.Set(pMappedTexture2d, deletable);
    }
};
/// <summary>
/// Provides access to subresource data in a 3D texture.
/// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE3D)</para>
/// </summary>
public ref struct MappedTexture3d 
{
public:
    /// <summary>
    /// Pointer to the data.
    /// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE3D.pData)</para>
    /// </summary>
    property IntPtr pData
    {
        IntPtr get()
        {
            return IntPtr(nativeObject->pData);
        }

        void set(IntPtr value)
        {
            nativeObject->pData = value.ToPointer();
        }
    }
    /// <summary>
    /// The pitch, or width, or physical size (in bytes) of one row of an uncompressed texture. Since a block-compressed texture is encoded in 4x4 blocks, the RowPitch for a compressed texture is the number of bytes in a block of 4x4 texels. See virtual size vs physical size for more information on block compression.
    /// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE3D.RowPitch)</para>
    /// </summary>
    property UInt32 RowPitch
    {
        UInt32 get()
        {
            return (nativeObject->RowPitch);
        }
        void set(UInt32 value)
        {
            nativeObject->RowPitch = value;
        }
    }
    /// <summary>
    /// The pitch or number of bytes in all rows for a single depth.
    /// <para>(Also see DirectX SDK: D3D10_MAPPED_TEXTURE3D.DepthPitch)</para>
    /// </summary>
    property UInt32 DepthPitch
    {
        UInt32 get()
        {
            return (nativeObject->DepthPitch);
        }
        void set(UInt32 value)
        {
            nativeObject->DepthPitch = value;
        }
    }
public:
    MappedTexture3d()
    {
        nativeObject.Set(new D3D10_MAPPED_TEXTURE3D());
    }
internal:
    AutoPointer<D3D10_MAPPED_TEXTURE3D> nativeObject;
internal:
    MappedTexture3d(D3D10_MAPPED_TEXTURE3D* pMappedTexture3d)
    {
        nativeObject.Set(pMappedTexture3d);
    }
    MappedTexture3d(D3D10_MAPPED_TEXTURE3D* pMappedTexture3d, bool deletable)
    {
        nativeObject.Set(pMappedTexture3d, deletable);
    }
};
/// <summary>
/// A debug message in the Information Queue.
/// <para>(Also see DirectX SDK: D3D10_MESSAGE)</para>
/// </summary>
public ref struct Message 
{
public:
    /// <summary>
    /// The category of the message. See MessageCategory.
    /// <para>(Also see DirectX SDK: D3D10_MESSAGE.Category)</para>
    /// </summary>
    property MessageCategory Category
    {
        MessageCategory get()
        {
            return (MessageCategory)(nativeObject->Category);
        }
        void set(MessageCategory value)
        {
            nativeObject->Category = (D3D10_MESSAGE_CATEGORY)value;
        }
    }
    /// <summary>
    /// The severity of the message. See MessageSeverity.
    /// <para>(Also see DirectX SDK: D3D10_MESSAGE.Severity)</para>
    /// </summary>
    property MessageSeverity Severity
    {
        MessageSeverity get()
        {
            return (MessageSeverity)(nativeObject->Severity);
        }
        void set(MessageSeverity value)
        {
            nativeObject->Severity = (D3D10_MESSAGE_SEVERITY)value;
        }
    }
    /// <summary>
    /// The ID of the message. See MessageId.
    /// <para>(Also see DirectX SDK: D3D10_MESSAGE.ID)</para>
    /// </summary>
    property MessageId ID
    {
        MessageId get()
        {
            return (MessageId)(nativeObject->ID);
        }
        void set(MessageId value)
        {
            nativeObject->ID = (D3D10_MESSAGE_ID)value;
        }
    }
    /// <summary>
    /// The message string.
    /// <para>(Also see DirectX SDK: D3D10_MESSAGE.pDescription)</para>
    /// </summary>
    property String^ pDescription
    {
        String^ get()
        {
            if (nativeObject->pDescription == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->pDescription);
        }
    }
    /// <summary>
    /// The length of pDescription in bytes.
    /// <para>(Also see DirectX SDK: D3D10_MESSAGE.DescriptionByteLength)</para>
    /// </summary>
    property UInt32 DescriptionByteLength
    {
        UInt32 get()
        {
            return (nativeObject->DescriptionByteLength);
        }
        void set(UInt32 value)
        {
            nativeObject->DescriptionByteLength = (SIZE_T)value;
        }
    }
public:
    Message()
    {
        nativeObject.Set(new D3D10_MESSAGE());
    }
internal:
    AutoPointer<D3D10_MESSAGE> nativeObject;
internal:
    Message(D3D10_MESSAGE* pMessage)
    {
        nativeObject.Set(pMessage);
    }
    Message(D3D10_MESSAGE* pMessage, bool deletable)
    {
        nativeObject.Set(pMessage, deletable);
    }
};
/// <summary>
/// Describes an effect pass, which contains pipeline state.
/// <para>(Also see DirectX SDK: D3D10_PASS_DESC)</para>
/// </summary>
public ref struct PassDescription 
{
public:
    /// <summary>
    /// A string that contains the name of the pass; otherwise NULL.
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The number of annotations.
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.Annotations)</para>
    /// </summary>
    property UInt32 Annotations
    {
        UInt32 get()
        {
            return (nativeObject->Annotations);
        }
        void set(UInt32 value)
        {
            nativeObject->Annotations = value;
        }
    }
    /// <summary>
    /// The input signature or the vertex shader; otherwise NULL.
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.pIAInputSignature)</para>
    /// </summary>
    property IntPtr pIAInputSignature
    {
        IntPtr get()
        {
            return IntPtr(nativeObject->pIAInputSignature);
        }

        void set(IntPtr value)
        {
            nativeObject->pIAInputSignature = (BYTE*) value.ToPointer();
        }
    }
    /// <summary>
    /// The size of the input signature (in bytes).
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.IAInputSignatureSize)</para>
    /// </summary>
    property UInt32 IAInputSignatureSize
    {
        UInt32 get()
        {
            return (nativeObject->IAInputSignatureSize);
        }
        void set(UInt32 value)
        {
            nativeObject->IAInputSignatureSize = (SIZE_T)value;
        }
    }
    /// <summary>
    /// The stencil-reference value used in the depth-stencil state (see Configuring Depth-Stencil Functionality (Direct3D 10)).
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.StencilRef)</para>
    /// </summary>
    property UInt32 StencilRef
    {
        UInt32 get()
        {
            return (nativeObject->StencilRef);
        }
        void set(UInt32 value)
        {
            nativeObject->StencilRef = value;
        }
    }
    /// <summary>
    /// The sample mask for the blend state (see Configuring Blending Functionality (Direct3D 10)).
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.SampleMask)</para>
    /// </summary>
    property UInt32 SampleMask
    {
        UInt32 get()
        {
            return (nativeObject->SampleMask);
        }
        void set(UInt32 value)
        {
            nativeObject->SampleMask = value;
        }
    }
    /// <summary>
    /// The per-component blend factors (RGBA) for the blend state (see Configuring Blending Functionality (Direct3D 10)).
    /// <para>(Also see DirectX SDK: D3D10_PASS_DESC.BlendFactor)</para>
    /// </summary>
    property Single BlendFactor[int]
    {
        Single get(int i)
        {
            if (i < 0 || i >= BlendFactorArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            return nativeObject->BlendFactor[i];
        }

        void set(int i, Single value)
        {
            if (i < 0 || i >= BlendFactorArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            nativeObject->BlendFactor[i] = value;
        }
    }
public:
    PassDescription()
    {
        nativeObject.Set(new D3D10_PASS_DESC());
    }
internal:
    AutoPointer<D3D10_PASS_DESC> nativeObject;
internal:
    PassDescription(D3D10_PASS_DESC* pPassDescription)
    {
        nativeObject.Set(pPassDescription);
    }
    PassDescription(D3D10_PASS_DESC* pPassDescription, bool deletable)
    {
        nativeObject.Set(pPassDescription, deletable);
    }
public:
        literal int BlendFactorArrayLength = 4;
private:
    marshal_context^ context;
};
ref class EffectShaderVariable;
/// <summary>
/// Describes an effect variable that contains a shader.
/// <para>(Also see DirectX SDK: D3D10_PASS_SHADER_DESC)</para>
/// </summary>
public ref struct PassShaderDescription 
{
public:
    /// <summary>
    /// The variable that the shader came from. If it is an inline shader assignment, the returned interface will be an anonymous shader variable, which is not retrievable any other way.  Its name in the variable description will be "$Anonymous". If there is no assignment of this type in the pass block, this will point to a shader variable that returns false when IsValid is called.
    /// <para>(Also see DirectX SDK: D3D10_PASS_SHADER_DESC.pShaderVariable)</para>
    /// </summary>
    EffectShaderVariable^ pShaderVariable;
    /// <summary>
    /// A zero-based array index; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_PASS_SHADER_DESC.ShaderIndex)</para>
    /// </summary>
    property UInt32 ShaderIndex
    {
        UInt32 get()
        {
            return (nativeObject->ShaderIndex);
        }
        void set(UInt32 value)
        {
            nativeObject->ShaderIndex = value;
        }
    }
public:
    PassShaderDescription()
    {
        nativeObject.Set(new D3D10_PASS_SHADER_DESC());
    }
internal:
    AutoPointer<D3D10_PASS_SHADER_DESC> nativeObject;
internal:
    PassShaderDescription(D3D10_PASS_SHADER_DESC* pPassShaderDescription)
    {
        nativeObject.Set(pPassShaderDescription);
    }
    PassShaderDescription(D3D10_PASS_SHADER_DESC* pPassShaderDescription, bool deletable)
    {
        nativeObject.Set(pPassShaderDescription, deletable);
    }
};
/// <summary>
/// Query information about graphics-pipeline activity in between calls to Asynchronous.Begin and Asynchronous.End.
/// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS)</para>
/// </summary>
public ref struct QueryDataPipelineStatistics 
{
public:
    /// <summary>
    /// Number of vertices read by input assembler.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.IAVertices)</para>
    /// </summary>
    property UInt64 IAVertices
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->IAVertices);
        }
        void set(UInt64 value)
        {
            nativeObject->IAVertices = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of primitives read by the input assembler. This number can be different depending on the primitive topology used. For example, a triangle strip with 6 vertices will produce 4 triangles, however a triangle list with 6 vertices will produce 2 triangles.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.IAPrimitives)</para>
    /// </summary>
    property UInt64 IAPrimitives
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->IAPrimitives);
        }
        void set(UInt64 value)
        {
            nativeObject->IAPrimitives = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of times a vertex shader was invoked. Direct3D invokes the vertex shader once per vertex.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.VSInvocations)</para>
    /// </summary>
    property UInt64 VSInvocations
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->VSInvocations);
        }
        void set(UInt64 value)
        {
            nativeObject->VSInvocations = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of times a geometry shader was invoked. When the geometry shader is set to NULL, this statistic may or may not increment depending on the hardware manufacturer.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.GSInvocations)</para>
    /// </summary>
    property UInt64 GSInvocations
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->GSInvocations);
        }
        void set(UInt64 value)
        {
            nativeObject->GSInvocations = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of primitives output by a geometry shader.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.GSPrimitives)</para>
    /// </summary>
    property UInt64 GSPrimitives
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->GSPrimitives);
        }
        void set(UInt64 value)
        {
            nativeObject->GSPrimitives = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of primitives that were sent to the rasterizer. When the rasterizer is disabled, this will not increment.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.CInvocations)</para>
    /// </summary>
    property UInt64 CInvocations
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->CInvocations);
        }
        void set(UInt64 value)
        {
            nativeObject->CInvocations = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of primitives that were rendered. This may be larger or smaller than CInvocations because after a primitive is clipped sometimes it is either broken up into more than one primitive or completely culled.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.CPrimitives)</para>
    /// </summary>
    property UInt64 CPrimitives
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->CPrimitives);
        }
        void set(UInt64 value)
        {
            nativeObject->CPrimitives = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of times a pixel shader was invoked.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_PIPELINE_STATISTICS.PSInvocations)</para>
    /// </summary>
    property UInt64 PSInvocations
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->PSInvocations);
        }
        void set(UInt64 value)
        {
            nativeObject->PSInvocations = (UINT64)value;
        }
    }
public:
    QueryDataPipelineStatistics()
    {
        nativeObject.Set(new D3D10_QUERY_DATA_PIPELINE_STATISTICS());
    }
internal:
    AutoPointer<D3D10_QUERY_DATA_PIPELINE_STATISTICS> nativeObject;
internal:
    QueryDataPipelineStatistics(D3D10_QUERY_DATA_PIPELINE_STATISTICS* pQueryDataPipelineStatistics)
    {
        nativeObject.Set(pQueryDataPipelineStatistics);
    }
    QueryDataPipelineStatistics(D3D10_QUERY_DATA_PIPELINE_STATISTICS* pQueryDataPipelineStatistics, bool deletable)
    {
        nativeObject.Set(pQueryDataPipelineStatistics, deletable);
    }
};
/// <summary>
/// Query information about the amount of data streamed out to the stream-output buffers in between Asynchronous.Begin and Asynchronous.End.
/// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_SO_STATISTICS)</para>
/// </summary>
public ref struct QueryDataSoStatistics 
{
public:
    /// <summary>
    /// Number of primitives (that is, points, lines, and triangles) written to the stream-output buffers.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_SO_STATISTICS.NumPrimitivesWritten)</para>
    /// </summary>
    property UInt64 NumPrimitivesWritten
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->NumPrimitivesWritten);
        }
        void set(UInt64 value)
        {
            nativeObject->NumPrimitivesWritten = (UINT64)value;
        }
    }
    /// <summary>
    /// Number of primitives that would have been written to the stream-output buffers if there had been enough space for them all.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_SO_STATISTICS.PrimitivesStorageNeeded)</para>
    /// </summary>
    property UInt64 PrimitivesStorageNeeded
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->PrimitivesStorageNeeded);
        }
        void set(UInt64 value)
        {
            nativeObject->PrimitivesStorageNeeded = (UINT64)value;
        }
    }
public:
    QueryDataSoStatistics()
    {
        nativeObject.Set(new D3D10_QUERY_DATA_SO_STATISTICS());
    }
internal:
    AutoPointer<D3D10_QUERY_DATA_SO_STATISTICS> nativeObject;
internal:
    QueryDataSoStatistics(D3D10_QUERY_DATA_SO_STATISTICS* pQueryDataSoStatistics)
    {
        nativeObject.Set(pQueryDataSoStatistics);
    }
    QueryDataSoStatistics(D3D10_QUERY_DATA_SO_STATISTICS* pQueryDataSoStatistics, bool deletable)
    {
        nativeObject.Set(pQueryDataSoStatistics, deletable);
    }
};
/// <summary>
/// Query information about the reliability of a timestamp query.
/// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_TIMESTAMP_DISJOINT)</para>
/// </summary>
public ref struct QueryDataTimestampDisjoint 
{
public:
    /// <summary>
    /// How frequently the GPU counter increments in Hz.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_TIMESTAMP_DISJOINT.Frequency)</para>
    /// </summary>
    property UInt64 Frequency
    {
        UInt64 get()
        {
            return (UInt64)(nativeObject->Frequency);
        }
        void set(UInt64 value)
        {
            nativeObject->Frequency = (UINT64)value;
        }
    }
    /// <summary>
    /// If this is TRUE, something occurred in between the query's Asynchronous.Begin and Asynchronous.End calls that caused the timestamp counter to become discontinuous or disjoint, such as unplugging the AC chord on a laptop, overheating, or throttling up/down due to laptop savings events. The timestamp returned by Asynchronous.GetData for a timestamp query is only reliable if Disjoint is FALSE.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DATA_TIMESTAMP_DISJOINT.Disjoint)</para>
    /// </summary>
    property Boolean Disjoint
    {
        Boolean get()
        {
            return nativeObject->Disjoint != 0;
        }
        void set(Boolean value)
        {
            nativeObject->Disjoint = (BOOL)value;
        }
    }
public:
    QueryDataTimestampDisjoint()
    {
        nativeObject.Set(new D3D10_QUERY_DATA_TIMESTAMP_DISJOINT());
    }
internal:
    AutoPointer<D3D10_QUERY_DATA_TIMESTAMP_DISJOINT> nativeObject;
internal:
    QueryDataTimestampDisjoint(D3D10_QUERY_DATA_TIMESTAMP_DISJOINT* pQueryDataTimestampDisjoint)
    {
        nativeObject.Set(pQueryDataTimestampDisjoint);
    }
    QueryDataTimestampDisjoint(D3D10_QUERY_DATA_TIMESTAMP_DISJOINT* pQueryDataTimestampDisjoint, bool deletable)
    {
        nativeObject.Set(pQueryDataTimestampDisjoint, deletable);
    }
};
/// <summary>
/// Describes a query.
/// <para>(Also see DirectX SDK: D3D10_QUERY_DESC)</para>
/// </summary>
public ref struct QueryDescription 
{
public:
    /// <summary>
    /// Type of query.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DESC.D3DQuery)</para>
    /// </summary>
    property QueryType Query
    {
        QueryType get()
        {
            return (QueryType)(nativeObject->Query);
        }
        void set(QueryType value)
        {
            nativeObject->Query = (D3D10_QUERY)value;
        }
    }
    /// <summary>
    /// Miscellaneous flags (see <see cref="QueryMiscFlag"/>)<seealso cref="QueryMiscFlag"/>.
    /// <para>(Also see DirectX SDK: D3D10_QUERY_DESC.MiscFlags)</para>
    /// </summary>
    property UInt32 MiscFlags
    {
        UInt32 get()
        {
            return (nativeObject->MiscFlags);
        }
        void set(UInt32 value)
        {
            nativeObject->MiscFlags = value;
        }
    }
public:
    QueryDescription()
    {
        nativeObject.Set(new D3D10_QUERY_DESC());
    }
internal:
    AutoPointer<D3D10_QUERY_DESC> nativeObject;
internal:
    QueryDescription(D3D10_QUERY_DESC* pQueryDescription)
    {
        nativeObject.Set(pQueryDescription);
    }
    QueryDescription(D3D10_QUERY_DESC* pQueryDescription, bool deletable)
    {
        nativeObject.Set(pQueryDescription, deletable);
    }
};
/// <summary>
/// Describes the rasterizer state.
/// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC)</para>
/// </summary>
public ref struct RasterizerDescription 
{
public:
    /// <summary>
    /// A member of the FillMode enumerated type that determines the fill mode to use when rendering.  The default value is Solid.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.FillMode)</para>
    /// </summary>
    property FillMode RasterizerFillMode
    {
        FillMode get()
        {
            return (FillMode)(nativeObject->FillMode);
        }
        void set(FillMode value)
        {
            nativeObject->FillMode = (D3D10_FILL_MODE)value;
        }
    }
    /// <summary>
    /// A member of the CullMode enumerated type that indicates whether triangles facing the specified direction are drawn.  The default value is Back.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.CullMode)</para>
    /// </summary>
    property CullMode RasterizerCullMode
    {
        CullMode get()
        {
            return (CullMode)(nativeObject->CullMode);
        }
        void set(CullMode value)
        {
            nativeObject->CullMode = (D3D10_CULL_MODE)value;
        }
    }
    /// <summary>
    /// Determines if a triangle is front-facing or back-facing. If this parameter is TRUE, then a triangle is considered front-facing if its vertices are counter-clockwise on the render target, and considered back-facing if they are clockwise. If this parameter is FALSE, then the opposite is true.  The default value is FALSE.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.FrontCounterClockwise)</para>
    /// </summary>
    property Boolean FrontCounterClockwise
    {
        Boolean get()
        {
            return nativeObject->FrontCounterClockwise != 0;
        }
        void set(Boolean value)
        {
            nativeObject->FrontCounterClockwise = (BOOL)value;
        }
    }
    /// <summary>
    /// Specifies the depth value added to a given pixel. The default value is 0. For more information, see Depth Bias.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.DepthBias)</para>
    /// </summary>
    property Int32 DepthBias
    {
        Int32 get()
        {
            return (Int32)(nativeObject->DepthBias);
        }
        void set(Int32 value)
        {
            nativeObject->DepthBias = (INT)value;
        }
    }
    /// <summary>
    /// Specifies the maximum depth bias of a pixel. The default value is 0.0f. For more information, see Depth Bias.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.DepthBiasClamp)</para>
    /// </summary>
    property Single DepthBiasClamp
    {
        Single get()
        {
            return (nativeObject->DepthBiasClamp);
        }
        void set(Single value)
        {
            nativeObject->DepthBiasClamp = value;
        }
    }
    /// <summary>
    /// Specifies a scalar on a given pixel's slope. The default value is 0.0f. For more information, see Depth Bias.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.SlopeScaledDepthBias)</para>
    /// </summary>
    property Single SlopeScaledDepthBias
    {
        Single get()
        {
            return (nativeObject->SlopeScaledDepthBias);
        }
        void set(Single value)
        {
            nativeObject->SlopeScaledDepthBias = value;
        }
    }
    /// <summary>
    /// Enables or disables clipping based on distance.  The default value is TRUE.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.DepthClipEnable)</para>
    /// </summary>
    property Boolean DepthClipEnable
    {
        Boolean get()
        {
            return nativeObject->DepthClipEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->DepthClipEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// Enable or disables scissor-rectangle culling. All pixels outside an active scissor rectangle are culled. The default value is FALSE. For more information, see Set the Scissor Rectangle.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.ScissorEnable)</para>
    /// </summary>
    property Boolean ScissorEnable
    {
        Boolean get()
        {
            return nativeObject->ScissorEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->ScissorEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// Enables or disables multisample antialiasing.  The default value is FALSE.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.MultisampleEnable)</para>
    /// </summary>
    property Boolean MultisampleEnable
    {
        Boolean get()
        {
            return nativeObject->MultisampleEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->MultisampleEnable = (BOOL)value;
        }
    }
    /// <summary>
    /// Enable or disables line antialiasing. Note that this option only applies when alpha blending is enabled, you are drawing lines, and the MultisampleEnable member is FALSE.  The default value is FALSE.
    /// <para>(Also see DirectX SDK: D3D10_RASTERIZER_DESC.AntialiasedLineEnable)</para>
    /// </summary>
    property Boolean AntialiasedLineEnable
    {
        Boolean get()
        {
            return nativeObject->AntialiasedLineEnable != 0;
        }
        void set(Boolean value)
        {
            nativeObject->AntialiasedLineEnable = (BOOL)value;
        }
    }
public:
    RasterizerDescription()
    {
        nativeObject.Set(new D3D10_RASTERIZER_DESC());
    }
internal:
    AutoPointer<D3D10_RASTERIZER_DESC> nativeObject;
internal:
    RasterizerDescription(D3D10_RASTERIZER_DESC* pRasterizerDescription)
    {
        nativeObject.Set(pRasterizerDescription);
    }
    RasterizerDescription(D3D10_RASTERIZER_DESC* pRasterizerDescription, bool deletable)
    {
        nativeObject.Set(pRasterizerDescription, deletable);
    }
};
/// <summary>
/// Specifies the subresource(s) from a resource that are accessible using a render-target view.
/// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC)</para>
/// </summary>
public ref struct RenderTargetViewDescription 
{
public:
    /// <summary>
    /// The data format (see <see cref="Format"/>)<seealso cref="Format"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// The resource type (see <see cref="RenderTargetViewDimension"/>)<seealso cref="RenderTargetViewDimension"/>, which specifies how the render-target resource will be accessed.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.ViewDimension)</para>
    /// </summary>
    property RenderTargetViewDimension ViewDimension
    {
        RenderTargetViewDimension get()
        {
            return (RenderTargetViewDimension)(nativeObject->ViewDimension);
        }
        void set(RenderTargetViewDimension value)
        {
            nativeObject->ViewDimension = (D3D10_RTV_DIMENSION)value;
        }
    }
    /// <summary>
    /// Specifies which buffer elements can be accessed (see <see cref="BufferRenderTargetView"/>)<seealso cref="BufferRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Buffer)</para>
    /// </summary>
    property BufferRenderTargetView^ Buffer
    {
        BufferRenderTargetView^ get()
        {
            return gcnew BufferRenderTargetView(&(nativeObject->Buffer), false);
        }
        void set(BufferRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Buffer), (void*)(value->nativeObject.Get()), sizeof(D3D10_BUFFER_RTV));
        }
    }
    /// <summary>
    /// Specifies the subresources in a 1D texture that can be accessed (see <see cref="Texture1dRenderTargetView"/>)<seealso cref="Texture1dRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture1D)</para>
    /// </summary>
    property Texture1dRenderTargetView^ Texture1d
    {
        Texture1dRenderTargetView^ get()
        {
            return gcnew Texture1dRenderTargetView(&(nativeObject->Texture1D), false);
        }
        void set(Texture1dRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture1D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_RTV));
        }
    }
    /// <summary>
    /// Specifies the subresources in a 1D texture array that can be accessed (see <see cref="Texture1dArrayRenderTargetView"/>)<seealso cref="Texture1dArrayRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture1dArray)</para>
    /// </summary>
    property Texture1dArrayRenderTargetView^ Texture1dArray
    {
        Texture1dArrayRenderTargetView^ get()
        {
            return gcnew Texture1dArrayRenderTargetView(&(nativeObject->Texture1DArray), false);
        }
        void set(Texture1dArrayRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture1DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_ARRAY_RTV));
        }
    }
    /// <summary>
    /// Specifies the subresources in a 2D texture that can be accessed (see <see cref="Texture2dRenderTargetView"/>)<seealso cref="Texture2dRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture2D)</para>
    /// </summary>
    property Texture2dRenderTargetView^ Texture2d
    {
        Texture2dRenderTargetView^ get()
        {
            return gcnew Texture2dRenderTargetView(&(nativeObject->Texture2D), false);
        }
        void set(Texture2dRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture2D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_RTV));
        }
    }
    /// <summary>
    /// Specifies the subresources in a 2D texture array that can be accessed (see <see cref="Texture2dArrayRenderTargetView"/>)<seealso cref="Texture2dArrayRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture2dArray)</para>
    /// </summary>
    property Texture2dArrayRenderTargetView^ Texture2dArray
    {
        Texture2dArrayRenderTargetView^ get()
        {
            return gcnew Texture2dArrayRenderTargetView(&(nativeObject->Texture2DArray), false);
        }
        void set(Texture2dArrayRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture2DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_ARRAY_RTV));
        }
    }
    /// <summary>
    /// Specifies a single subresource because a multisampled 2D texture only contains one subresource (see <see cref="Texture2dMultiSampleRenderTargetView"/>)<seealso cref="Texture2dMultiSampleRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture2dMultiSample)</para>
    /// </summary>
    property Texture2dMultiSampleRenderTargetView^ Texture2dMultiSample
    {
        Texture2dMultiSampleRenderTargetView^ get()
        {
            return gcnew Texture2dMultiSampleRenderTargetView(&(nativeObject->Texture2DMS), false);
        }
        void set(Texture2dMultiSampleRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture2DMS), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_RTV));
        }
    }
    /// <summary>
    /// Specifies the subresources in a multisampled 2D texture array that can be accessed (see <see cref="Texture2dMultiSampleArrayRenderTargetView"/>)<seealso cref="Texture2dMultiSampleArrayRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture2DMSArray)</para>
    /// </summary>
    property Texture2dMultiSampleArrayRenderTargetView^ Texture2dMSArray
    {
        Texture2dMultiSampleArrayRenderTargetView^ get()
        {
            return gcnew Texture2dMultiSampleArrayRenderTargetView(&(nativeObject->Texture2DMSArray), false);
        }
        void set(Texture2dMultiSampleArrayRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture2DMSArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_ARRAY_RTV));
        }
    }
    /// <summary>
    /// Specifies subresources in a 3D texture that can be accessed (see <see cref="Texture3dRenderTargetView"/>)<seealso cref="Texture3dRenderTargetView"/>.
    /// <para>(Also see DirectX SDK: D3D10_RENDER_TARGET_VIEW_DESC.Texture3D)</para>
    /// </summary>
    property Texture3dRenderTargetView^ Texture3d
    {
        Texture3dRenderTargetView^ get()
        {
            return gcnew Texture3dRenderTargetView(&(nativeObject->Texture3D), false);
        }
        void set(Texture3dRenderTargetView^ value)
        {
            memcpy(&(nativeObject->Texture3D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX3D_RTV));
        }
    }
public:
    RenderTargetViewDescription()
    {
        nativeObject.Set(new D3D10_RENDER_TARGET_VIEW_DESC());
    }
internal:
    AutoPointer<D3D10_RENDER_TARGET_VIEW_DESC> nativeObject;
internal:
    RenderTargetViewDescription(D3D10_RENDER_TARGET_VIEW_DESC* pRenderTargetViewDescription)
    {
        nativeObject.Set(pRenderTargetViewDescription);
    }
    RenderTargetViewDescription(D3D10_RENDER_TARGET_VIEW_DESC* pRenderTargetViewDescription, bool deletable)
    {
        nativeObject.Set(pRenderTargetViewDescription, deletable);
    }
};
/// <summary>
/// Describes a sampler state.
/// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC)</para>
/// </summary>
public ref struct SamplerDescription 
{
public:
    /// <summary>
    /// Filtering method to use when sampling a texture (see <see cref="Filter"/>)<seealso cref="Filter"/>.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.Filter)</para>
    /// </summary>
    property Filter FilterMethod
    {
        Filter get()
        {
            return (Filter)(nativeObject->Filter);
        }
        void set(Filter value)
        {
            nativeObject->Filter = (D3D10_FILTER)value;
        }
    }
    /// <summary>
    /// Method to use for resolving a u texture coordinate that is outside the 0 to 1 range (see <see cref="TextureAddressMode"/>)<seealso cref="TextureAddressMode"/>.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.AddressU)</para>
    /// </summary>
    property TextureAddressMode AddressU
    {
        TextureAddressMode get()
        {
            return (TextureAddressMode)(nativeObject->AddressU);
        }
        void set(TextureAddressMode value)
        {
            nativeObject->AddressU = (D3D10_TEXTURE_ADDRESS_MODE)value;
        }
    }
    /// <summary>
    /// Method to use for resolving a v texture coordinate that is outside the 0 to 1 range.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.AddressV)</para>
    /// </summary>
    property TextureAddressMode AddressV
    {
        TextureAddressMode get()
        {
            return (TextureAddressMode)(nativeObject->AddressV);
        }
        void set(TextureAddressMode value)
        {
            nativeObject->AddressV = (D3D10_TEXTURE_ADDRESS_MODE)value;
        }
    }
    /// <summary>
    /// Method to use for resolving a w texture coordinate that is outside the 0 to 1 range.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.AddressW)</para>
    /// </summary>
    property TextureAddressMode AddressW
    {
        TextureAddressMode get()
        {
            return (TextureAddressMode)(nativeObject->AddressW);
        }
        void set(TextureAddressMode value)
        {
            nativeObject->AddressW = (D3D10_TEXTURE_ADDRESS_MODE)value;
        }
    }
    /// <summary>
    /// Offset from the calculated mipmap level. For example, if Direct3D calculates that a texture should be sampled at mipmap level 3 and MipLODBias is 2, then the texture will be sampled at mipmap level 5.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.MipLODBias)</para>
    /// </summary>
    property Single MipLODBias
    {
        Single get()
        {
            return (nativeObject->MipLODBias);
        }
        void set(Single value)
        {
            nativeObject->MipLODBias = value;
        }
    }
    /// <summary>
    /// Clamping value used if Anisotropic or ComparisonAnisotropic is specified in Filter. Valid values are between 1 and 16.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.MaxAnisotropy)</para>
    /// </summary>
    property UInt32 MaxAnisotropy
    {
        UInt32 get()
        {
            return (nativeObject->MaxAnisotropy);
        }
        void set(UInt32 value)
        {
            nativeObject->MaxAnisotropy = value;
        }
    }
    /// <summary>
    /// A function that compares sampled data against existing sampled data. The function options are listed in ComparisonFunction.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.ComparisonFunc)</para>
    /// </summary>
    property D3D10::ComparisonFunction ComparisonFunction
    {
        D3D10::ComparisonFunction get()
        {
            return (D3D10::ComparisonFunction)(nativeObject->ComparisonFunc);
        }
        void set(D3D10::ComparisonFunction value)
        {
            nativeObject->ComparisonFunc = (D3D10_COMPARISON_FUNC)value;
        }
    }
    /// <summary>
    /// Border color to use if Border is specified for AddressU, AddressV, or AddressW. Range must be between 0.0 and 1.0 inclusive.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.BorderColor)</para>
    /// </summary>
    property Single BorderColor[int]
    {
        Single get(int i)
        {
            if (i < 0 || i >= BorderColorArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            return nativeObject->BorderColor[i];
        }

        void set(int i, Single value)
        {
            if (i < 0 || i >= BorderColorArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            nativeObject->BorderColor[i] = value;
        }
    }
    /// <summary>
    /// Lower end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.MinLOD)</para>
    /// </summary>
    property Single MinLOD
    {
        Single get()
        {
            return (nativeObject->MinLOD);
        }
        void set(Single value)
        {
            nativeObject->MinLOD = value;
        }
    }
    /// <summary>
    /// Upper end of the mipmap range to clamp access to, where 0 is the largest and most detailed mipmap level and any level higher than that is less detailed. This value must be greater than or equal to MinLOD. To have no upper limit on LOD set this to a large value such as D3D10_FLOAT32_MAX.
    /// <para>(Also see DirectX SDK: D3D10_SAMPLER_DESC.MaxLOD)</para>
    /// </summary>
    property Single MaxLOD
    {
        Single get()
        {
            return (nativeObject->MaxLOD);
        }
        void set(Single value)
        {
            nativeObject->MaxLOD = value;
        }
    }
public:
    SamplerDescription()
    {
        nativeObject.Set(new D3D10_SAMPLER_DESC());
    }
internal:
    AutoPointer<D3D10_SAMPLER_DESC> nativeObject;
internal:
    SamplerDescription(D3D10_SAMPLER_DESC* pSamplerDescription)
    {
        nativeObject.Set(pSamplerDescription);
    }
    SamplerDescription(D3D10_SAMPLER_DESC* pSamplerDescription, bool deletable)
    {
        nativeObject.Set(pSamplerDescription, deletable);
    }
private:
        literal int BorderColorArrayLength = 4;
};
/// <summary>
/// Describes a shader constant-buffer.
/// <para>(Also see DirectX SDK: D3D10_SHADER_BUFFER_DESC)</para>
/// </summary>
public ref struct ShaderBufferDescription 
{
public:
    /// <summary>
    /// The name of the buffer.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_BUFFER_DESC.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The intended use of the constant data. See ConstantBufferType.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_BUFFER_DESC.Type)</para>
    /// </summary>
    property ConstantBufferType Type
    {
        ConstantBufferType get()
        {
            return (ConstantBufferType)(nativeObject->Type);
        }
        void set(ConstantBufferType value)
        {
            nativeObject->Type = (D3D10_CBUFFER_TYPE)value;
        }
    }
    /// <summary>
    /// The number of unique variables.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_BUFFER_DESC.Variables)</para>
    /// </summary>
    property UInt32 Variables
    {
        UInt32 get()
        {
            return (nativeObject->Variables);
        }
        void set(UInt32 value)
        {
            nativeObject->Variables = value;
        }
    }
    /// <summary>
    /// Buffer size (in bytes).
    /// <para>(Also see DirectX SDK: D3D10_SHADER_BUFFER_DESC.Size)</para>
    /// </summary>
    property UInt32 Size
    {
        UInt32 get()
        {
            return (nativeObject->Size);
        }
        void set(UInt32 value)
        {
            nativeObject->Size = value;
        }
    }
    /// <summary>
    /// Shader buffer properties. See ShaderConstantBufferFlags.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_BUFFER_DESC.uFlags)</para>
    /// </summary>
    property UInt32 uFlags
    {
        UInt32 get()
        {
            return (nativeObject->uFlags);
        }
        void set(UInt32 value)
        {
            nativeObject->uFlags = value;
        }
    }
public:
    ShaderBufferDescription()
    {
        nativeObject.Set(new D3D10_SHADER_BUFFER_DESC());
    }
internal:
    AutoPointer<D3D10_SHADER_BUFFER_DESC> nativeObject;
internal:
    ShaderBufferDescription(D3D10_SHADER_BUFFER_DESC* pShaderBufferDescription)
    {
        nativeObject.Set(pShaderBufferDescription);
    }
    ShaderBufferDescription(D3D10_SHADER_BUFFER_DESC* pShaderBufferDescription, bool deletable)
    {
        nativeObject.Set(pShaderBufferDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Describes files included by a shader.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_FILE_INFO)</para>
/// </summary>
public ref struct ShaderDebugFileInfo 
{
public:
    /// <summary>
    /// Offset to the LPCSTR for the file name.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_FILE_INFO.FileName)</para>
    /// </summary>
    property UInt32 FileName
    {
        UInt32 get()
        {
            return (nativeObject->FileName);
        }
        void set(UInt32 value)
        {
            nativeObject->FileName = value;
        }
    }
    /// <summary>
    /// Length of the file name.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_FILE_INFO.FileNameLen)</para>
    /// </summary>
    property UInt32 FileNameLen
    {
        UInt32 get()
        {
            return (nativeObject->FileNameLen);
        }
        void set(UInt32 value)
        {
            nativeObject->FileNameLen = value;
        }
    }
    /// <summary>
    /// Offset to the file data.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_FILE_INFO.FileData)</para>
    /// </summary>
    property UInt32 FileData
    {
        UInt32 get()
        {
            return (nativeObject->FileData);
        }
        void set(UInt32 value)
        {
            nativeObject->FileData = value;
        }
    }
    /// <summary>
    /// Length of the file.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_FILE_INFO.FileLen)</para>
    /// </summary>
    property UInt32 FileLen
    {
        UInt32 get()
        {
            return (nativeObject->FileLen);
        }
        void set(UInt32 value)
        {
            nativeObject->FileLen = value;
        }
    }
public:
    ShaderDebugFileInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_FILE_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_FILE_INFO> nativeObject;
internal:
    ShaderDebugFileInfo(D3D10_SHADER_DEBUG_FILE_INFO* pShaderDebugFileInfo)
    {
        nativeObject.Set(pShaderDebugFileInfo);
    }
    ShaderDebugFileInfo(D3D10_SHADER_DEBUG_FILE_INFO* pShaderDebugFileInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugFileInfo, deletable);
    }
};
/// <summary>
/// Describes the format of the Blob Object returned by D3D10GetShaderDebugInfo.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO)</para>
/// </summary>
public ref struct ShaderDebugInfo 
{
public:
    /// <summary>
    /// Size of this structure.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Size)</para>
    /// </summary>
    property UInt32 Size
    {
        UInt32 get()
        {
            return (nativeObject->Size);
        }
        void set(UInt32 value)
        {
            nativeObject->Size = value;
        }
    }
    /// <summary>
    /// Offset to LPCSTR for compiler version.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Creator)</para>
    /// </summary>
    property UInt32 Creator
    {
        UInt32 get()
        {
            return (nativeObject->Creator);
        }
        void set(UInt32 value)
        {
            nativeObject->Creator = value;
        }
    }
    /// <summary>
    /// Offset to LPCSTR for Entry point name.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.EntrypointName)</para>
    /// </summary>
    property UInt32 EntrypointName
    {
        UInt32 get()
        {
            return (nativeObject->EntrypointName);
        }
        void set(UInt32 value)
        {
            nativeObject->EntrypointName = value;
        }
    }
    /// <summary>
    /// Offset to LPCSTR for shader target.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.ShaderTarget)</para>
    /// </summary>
    property UInt32 ShaderTarget
    {
        UInt32 get()
        {
            return (nativeObject->ShaderTarget);
        }
        void set(UInt32 value)
        {
            nativeObject->ShaderTarget = value;
        }
    }
    /// <summary>
    /// Flags used to compile.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.CompileFlags)</para>
    /// </summary>
    property UInt32 CompileFlags
    {
        UInt32 get()
        {
            return (nativeObject->CompileFlags);
        }
        void set(UInt32 value)
        {
            nativeObject->CompileFlags = value;
        }
    }
    /// <summary>
    /// Number of included files.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Files)</para>
    /// </summary>
    property UInt32 Files
    {
        UInt32 get()
        {
            return (nativeObject->Files);
        }
        void set(UInt32 value)
        {
            nativeObject->Files = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugFileInfo structures that has Files elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.FileInfo)</para>
    /// </summary>
    property UInt32 FileInfo
    {
        UInt32 get()
        {
            return (nativeObject->FileInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->FileInfo = value;
        }
    }
    /// <summary>
    /// Number of instructions.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Instructions)</para>
    /// </summary>
    property UInt32 Instructions
    {
        UInt32 get()
        {
            return (nativeObject->Instructions);
        }
        void set(UInt32 value)
        {
            nativeObject->Instructions = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugInstInfo structures that has Instructions elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.InstructionInfo)</para>
    /// </summary>
    property UInt32 InstructionInfo
    {
        UInt32 get()
        {
            return (nativeObject->InstructionInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->InstructionInfo = value;
        }
    }
    /// <summary>
    /// Number of variables.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Variables)</para>
    /// </summary>
    property UInt32 Variables
    {
        UInt32 get()
        {
            return (nativeObject->Variables);
        }
        void set(UInt32 value)
        {
            nativeObject->Variables = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugVarInfo structures that has Variables elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.VariableInfo)</para>
    /// </summary>
    property UInt32 VariableInfo
    {
        UInt32 get()
        {
            return (nativeObject->VariableInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->VariableInfo = value;
        }
    }
    /// <summary>
    /// Number of variables to initialize before running.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.InputVariables)</para>
    /// </summary>
    property UInt32 InputVariables
    {
        UInt32 get()
        {
            return (nativeObject->InputVariables);
        }
        void set(UInt32 value)
        {
            nativeObject->InputVariables = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugInputInfo structures that has InputVariables elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.InputVariableInfo)</para>
    /// </summary>
    property UInt32 InputVariableInfo
    {
        UInt32 get()
        {
            return (nativeObject->InputVariableInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->InputVariableInfo = value;
        }
    }
    /// <summary>
    /// Number of tokens to initialize.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Tokens)</para>
    /// </summary>
    property UInt32 Tokens
    {
        UInt32 get()
        {
            return (nativeObject->Tokens);
        }
        void set(UInt32 value)
        {
            nativeObject->Tokens = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugTokenInfo structures that has Tokens elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.TokenInfo)</para>
    /// </summary>
    property UInt32 TokenInfo
    {
        UInt32 get()
        {
            return (nativeObject->TokenInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->TokenInfo = value;
        }
    }
    /// <summary>
    /// Number of scopes.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.Scopes)</para>
    /// </summary>
    property UInt32 Scopes
    {
        UInt32 get()
        {
            return (nativeObject->Scopes);
        }
        void set(UInt32 value)
        {
            nativeObject->Scopes = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugScopeInfo structures that has Scopes elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.ScopeInfo)</para>
    /// </summary>
    property UInt32 ScopeInfo
    {
        UInt32 get()
        {
            return (nativeObject->ScopeInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->ScopeInfo = value;
        }
    }
    /// <summary>
    /// Number of variables declared.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.ScopeVariables)</para>
    /// </summary>
    property UInt32 ScopeVariables
    {
        UInt32 get()
        {
            return (nativeObject->ScopeVariables);
        }
        void set(UInt32 value)
        {
            nativeObject->ScopeVariables = value;
        }
    }
    /// <summary>
    /// Offset to array of ShaderDebugScopevarInfo structures that has Scopes elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.ScopeVariableInfo)</para>
    /// </summary>
    property UInt32 ScopeVariableInfo
    {
        UInt32 get()
        {
            return (nativeObject->ScopeVariableInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->ScopeVariableInfo = value;
        }
    }
    /// <summary>
    /// Offset to the UINT datastore, all UINT offsets are from this offset.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.UintOffset)</para>
    /// </summary>
    property UInt32 UintOffset
    {
        UInt32 get()
        {
            return (nativeObject->UintOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->UintOffset = value;
        }
    }
    /// <summary>
    /// Offset to the string datastore, all string offsets are from this offset.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INFO.StringOffset)</para>
    /// </summary>
    property UInt32 StringOffset
    {
        UInt32 get()
        {
            return (nativeObject->StringOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->StringOffset = value;
        }
    }
public:
    ShaderDebugInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_INFO> nativeObject;
internal:
    ShaderDebugInfo(D3D10_SHADER_DEBUG_INFO* pShaderDebugInfo)
    {
        nativeObject.Set(pShaderDebugInfo);
    }
    ShaderDebugInfo(D3D10_SHADER_DEBUG_INFO* pShaderDebugInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugInfo, deletable);
    }
};
/// <summary>
/// Describes a shader input.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO)</para>
/// </summary>
public ref struct ShaderDebugInputInfo 
{
public:
    /// <summary>
    /// Index into array of variables to initialize.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO.Var)</para>
    /// </summary>
    property UInt32 Var
    {
        UInt32 get()
        {
            return (nativeObject->Var);
        }
        void set(UInt32 value)
        {
            nativeObject->Var = value;
        }
    }
    /// <summary>
    /// Must be Input, ConstantBuffer or TextureBuffer.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO.InitialRegisterSet)</para>
    /// </summary>
    property ShaderDebugRegisterType InitialRegisterSet
    {
        ShaderDebugRegisterType get()
        {
            return (ShaderDebugRegisterType)(nativeObject->InitialRegisterSet);
        }
        void set(ShaderDebugRegisterType value)
        {
            nativeObject->InitialRegisterSet = (D3D10_SHADER_DEBUG_REGTYPE)value;
        }
    }
    /// <summary>
    /// Will contain a cbuffer or tbuffer slot, geometry shader input primitive number, identifying register for an indexable temp, or -1.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO.InitialBank)</para>
    /// </summary>
    property UInt32 InitialBank
    {
        UInt32 get()
        {
            return (nativeObject->InitialBank);
        }
        void set(UInt32 value)
        {
            nativeObject->InitialBank = value;
        }
    }
    /// <summary>
    /// Register in register set.  InitialRegister will be -1 if it is temporary.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO.InitialRegister)</para>
    /// </summary>
    property UInt32 InitialRegister
    {
        UInt32 get()
        {
            return (nativeObject->InitialRegister);
        }
        void set(UInt32 value)
        {
            nativeObject->InitialRegister = value;
        }
    }
    /// <summary>
    /// Gives the component.  InitialComponent will be -1 it is temporary.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO.InitialComponent)</para>
    /// </summary>
    property UInt32 InitialComponent
    {
        UInt32 get()
        {
            return (nativeObject->InitialComponent);
        }
        void set(UInt32 value)
        {
            nativeObject->InitialComponent = value;
        }
    }
    /// <summary>
    /// Initial value if the variable is a literal.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INPUT_INFO.InitialValue)</para>
    /// </summary>
    property UInt32 InitialValue
    {
        UInt32 get()
        {
            return (nativeObject->InitialValue);
        }
        void set(UInt32 value)
        {
            nativeObject->InitialValue = value;
        }
    }
public:
    ShaderDebugInputInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_INPUT_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_INPUT_INFO> nativeObject;
internal:
    ShaderDebugInputInfo(D3D10_SHADER_DEBUG_INPUT_INFO* pShaderDebugInputInfo)
    {
        nativeObject.Set(pShaderDebugInputInfo);
    }
    ShaderDebugInputInfo(D3D10_SHADER_DEBUG_INPUT_INFO* pShaderDebugInputInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugInputInfo, deletable);
    }
};
/// <summary>
/// Instruction outputs.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR)</para>
/// </summary>
public ref struct ShaderDebugOutputvar 
{
public:
    /// <summary>
    /// The index variable being written to or if -1 it's not going to a variable.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.Var)</para>
    /// </summary>
    property UInt32 Var
    {
        UInt32 get()
        {
            return (nativeObject->Var);
        }
        void set(UInt32 value)
        {
            nativeObject->Var = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.uValueMin)</para>
    /// </summary>
    property UInt32 uValueMin
    {
        UInt32 get()
        {
            return (nativeObject->uValueMin);
        }
        void set(UInt32 value)
        {
            nativeObject->uValueMin = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.uValueMax)</para>
    /// </summary>
    property UInt32 uValueMax
    {
        UInt32 get()
        {
            return (nativeObject->uValueMax);
        }
        void set(UInt32 value)
        {
            nativeObject->uValueMax = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.iValueMin)</para>
    /// </summary>
    property Int32 iValueMin
    {
        Int32 get()
        {
            return (Int32)(nativeObject->iValueMin);
        }
        void set(Int32 value)
        {
            nativeObject->iValueMin = (INT)value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.iValueMax)</para>
    /// </summary>
    property Int32 iValueMax
    {
        Int32 get()
        {
            return (Int32)(nativeObject->iValueMax);
        }
        void set(Int32 value)
        {
            nativeObject->iValueMax = (INT)value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.fValueMin)</para>
    /// </summary>
    property Single fValueMin
    {
        Single get()
        {
            return (nativeObject->fValueMin);
        }
        void set(Single value)
        {
            nativeObject->fValueMin = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.fValueMax)</para>
    /// </summary>
    property Single fValueMax
    {
        Single get()
        {
            return (nativeObject->fValueMax);
        }
        void set(Single value)
        {
            nativeObject->fValueMax = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.bNaNPossible)</para>
    /// </summary>
    property Boolean bNaNPossible
    {
        Boolean get()
        {
            return nativeObject->bNaNPossible != 0;
        }
        void set(Boolean value)
        {
            nativeObject->bNaNPossible = (BOOL)value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTVAR.bInfPossible)</para>
    /// </summary>
    property Boolean bInfPossible
    {
        Boolean get()
        {
            return nativeObject->bInfPossible != 0;
        }
        void set(Boolean value)
        {
            nativeObject->bInfPossible = (BOOL)value;
        }
    }
public:
    ShaderDebugOutputvar()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_OUTPUTVAR());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_OUTPUTVAR> nativeObject;
internal:
    ShaderDebugOutputvar(D3D10_SHADER_DEBUG_OUTPUTVAR* pShaderDebugOutputvar)
    {
        nativeObject.Set(pShaderDebugOutputvar);
    }
    ShaderDebugOutputvar(D3D10_SHADER_DEBUG_OUTPUTVAR* pShaderDebugOutputvar, bool deletable)
    {
        nativeObject.Set(pShaderDebugOutputvar, deletable);
    }
};
/// <summary>
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO)</para>
/// </summary>
public ref struct ShaderDebugScopevarInfo 
{
public:
    /// <summary>
    /// Index into variable token.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.TokenId)</para>
    /// </summary>
    property UInt32 TokenId
    {
        UInt32 get()
        {
            return (nativeObject->TokenId);
        }
        void set(UInt32 value)
        {
            nativeObject->TokenId = value;
        }
    }
    /// <summary>
    /// Indicates whether this is a variable or function.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.VarType)</para>
    /// </summary>
    property ShaderDebugVartype VarType
    {
        ShaderDebugVartype get()
        {
            return (ShaderDebugVartype)(nativeObject->VarType);
        }
        void set(ShaderDebugVartype value)
        {
            nativeObject->VarType = (D3D10_SHADER_DEBUG_VARTYPE)value;
        }
    }
    /// <summary>
    /// Indicates the variable class.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.Class)</para>
    /// </summary>
    property ShaderVariableClass Class
    {
        ShaderVariableClass get()
        {
            return (ShaderVariableClass)(nativeObject->Class);
        }
        void set(ShaderVariableClass value)
        {
            nativeObject->Class = (D3D10_SHADER_VARIABLE_CLASS)value;
        }
    }
    /// <summary>
    /// Number of row for matrices.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.Rows)</para>
    /// </summary>
    property UInt32 Rows
    {
        UInt32 get()
        {
            return (nativeObject->Rows);
        }
        void set(UInt32 value)
        {
            nativeObject->Rows = value;
        }
    }
    /// <summary>
    /// Number of columns for vectors or matrices.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.Columns)</para>
    /// </summary>
    property UInt32 Columns
    {
        UInt32 get()
        {
            return (nativeObject->Columns);
        }
        void set(UInt32 value)
        {
            nativeObject->Columns = value;
        }
    }
    /// <summary>
    /// Gives a scope to look up struct members.  This member will be -1 if ShaderDebugScopevarInfo does not refer to a struct.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.StructMemberScope)</para>
    /// </summary>
    property UInt32 StructMemberScope
    {
        UInt32 get()
        {
            return (nativeObject->StructMemberScope);
        }
        void set(UInt32 value)
        {
            nativeObject->StructMemberScope = value;
        }
    }
    /// <summary>
    /// Number of array indices. For example a three dimensional array would have a value of 3 for uArrayIndices.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.uArrayIndices)</para>
    /// </summary>
    property UInt32 uArrayIndices
    {
        UInt32 get()
        {
            return (nativeObject->uArrayIndices);
        }
        void set(UInt32 value)
        {
            nativeObject->uArrayIndices = value;
        }
    }
    /// <summary>
    /// Offset to an array of UINT values uArrayIndices long.  The array contains the the maximum value for each index. For example an array a[3][2][1] would have the values {3,2,1} at the offset pointed to by ArrayElements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.ArrayElements)</para>
    /// </summary>
    property UInt32 ArrayElements
    {
        UInt32 get()
        {
            return (nativeObject->ArrayElements);
        }
        void set(UInt32 value)
        {
            nativeObject->ArrayElements = value;
        }
    }
    /// <summary>
    /// Offset to an array of UINT values uArrayIndices long.  The array contains the stride for each array index.  For example an array a[3][2][1] would have the values {2,1,1} at the offset pointed to by ArrayStrides.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.ArrayStrides)</para>
    /// </summary>
    property UInt32 ArrayStrides
    {
        UInt32 get()
        {
            return (nativeObject->ArrayStrides);
        }
        void set(UInt32 value)
        {
            nativeObject->ArrayStrides = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.uVariables)</para>
    /// </summary>
    property UInt32 uVariables
    {
        UInt32 get()
        {
            return (nativeObject->uVariables);
        }
        void set(UInt32 value)
        {
            nativeObject->uVariables = value;
        }
    }
    /// <summary>
    /// Index of the first variable, later variables are offsets from this one.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPEVAR_INFO.uFirstVariable)</para>
    /// </summary>
    property UInt32 uFirstVariable
    {
        UInt32 get()
        {
            return (nativeObject->uFirstVariable);
        }
        void set(UInt32 value)
        {
            nativeObject->uFirstVariable = value;
        }
    }
public:
    ShaderDebugScopevarInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_SCOPEVAR_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_SCOPEVAR_INFO> nativeObject;
internal:
    ShaderDebugScopevarInfo(D3D10_SHADER_DEBUG_SCOPEVAR_INFO* pShaderDebugScopevarInfo)
    {
        nativeObject.Set(pShaderDebugScopevarInfo);
    }
    ShaderDebugScopevarInfo(D3D10_SHADER_DEBUG_SCOPEVAR_INFO* pShaderDebugScopevarInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugScopevarInfo, deletable);
    }
};
/// <summary>
/// Contains scope data that maps variable names to debug variables.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPE_INFO)</para>
/// </summary>
public ref struct ShaderDebugScopeInfo 
{
public:
    /// <summary>
    /// Specifies the scope type.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPE_INFO.ScopeType)</para>
    /// </summary>
    property ShaderDebugScopetype ScopeType
    {
        ShaderDebugScopetype get()
        {
            return (ShaderDebugScopetype)(nativeObject->ScopeType);
        }
        void set(ShaderDebugScopetype value)
        {
            nativeObject->ScopeType = (D3D10_SHADER_DEBUG_SCOPETYPE)value;
        }
    }
    /// <summary>
    /// Offset to the name of scope in the strings list.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPE_INFO.Name)</para>
    /// </summary>
    property UInt32 Name
    {
        UInt32 get()
        {
            return (nativeObject->Name);
        }
        void set(UInt32 value)
        {
            nativeObject->Name = value;
        }
    }
    /// <summary>
    /// Length of the string pointed to by Name.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPE_INFO.uNameLen)</para>
    /// </summary>
    property UInt32 uNameLen
    {
        UInt32 get()
        {
            return (nativeObject->uNameLen);
        }
        void set(UInt32 value)
        {
            nativeObject->uNameLen = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPE_INFO.uVariables)</para>
    /// </summary>
    property UInt32 uVariables
    {
        UInt32 get()
        {
            return (nativeObject->uVariables);
        }
        void set(UInt32 value)
        {
            nativeObject->uVariables = value;
        }
    }
    /// <summary>
    /// Offset an array of UINT values with uVariables members contianing the scope variable list.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_SCOPE_INFO.VariableData)</para>
    /// </summary>
    property UInt32 VariableData
    {
        UInt32 get()
        {
            return (nativeObject->VariableData);
        }
        void set(UInt32 value)
        {
            nativeObject->VariableData = value;
        }
    }
public:
    ShaderDebugScopeInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_SCOPE_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_SCOPE_INFO> nativeObject;
internal:
    ShaderDebugScopeInfo(D3D10_SHADER_DEBUG_SCOPE_INFO* pShaderDebugScopeInfo)
    {
        nativeObject.Set(pShaderDebugScopeInfo);
    }
    ShaderDebugScopeInfo(D3D10_SHADER_DEBUG_SCOPE_INFO* pShaderDebugScopeInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugScopeInfo, deletable);
    }
};
/// <summary>
/// Serialized structures that get written to the file.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_TOKEN_INFO)</para>
/// </summary>
public ref struct ShaderDebugTokenInfo 
{
public:
    /// <summary>
    /// Offset into file list.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_TOKEN_INFO.File)</para>
    /// </summary>
    property UInt32 File
    {
        UInt32 get()
        {
            return (nativeObject->File);
        }
        void set(UInt32 value)
        {
            nativeObject->File = value;
        }
    }
    /// <summary>
    /// Line number.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_TOKEN_INFO.Line)</para>
    /// </summary>
    property UInt32 Line
    {
        UInt32 get()
        {
            return (nativeObject->Line);
        }
        void set(UInt32 value)
        {
            nativeObject->Line = value;
        }
    }
    /// <summary>
    /// Column number.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_TOKEN_INFO.Column)</para>
    /// </summary>
    property UInt32 Column
    {
        UInt32 get()
        {
            return (nativeObject->Column);
        }
        void set(UInt32 value)
        {
            nativeObject->Column = value;
        }
    }
    /// <summary>
    /// Length of the token.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_TOKEN_INFO.TokenLength)</para>
    /// </summary>
    property UInt32 TokenLength
    {
        UInt32 get()
        {
            return (nativeObject->TokenLength);
        }
        void set(UInt32 value)
        {
            nativeObject->TokenLength = value;
        }
    }
    /// <summary>
    /// Offset to LPCSTR of length TokenLength in string datastore.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_TOKEN_INFO.TokenId)</para>
    /// </summary>
    property UInt32 TokenId
    {
        UInt32 get()
        {
            return (nativeObject->TokenId);
        }
        void set(UInt32 value)
        {
            nativeObject->TokenId = value;
        }
    }
public:
    ShaderDebugTokenInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_TOKEN_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_TOKEN_INFO> nativeObject;
internal:
    ShaderDebugTokenInfo(D3D10_SHADER_DEBUG_TOKEN_INFO* pShaderDebugTokenInfo)
    {
        nativeObject.Set(pShaderDebugTokenInfo);
    }
    ShaderDebugTokenInfo(D3D10_SHADER_DEBUG_TOKEN_INFO* pShaderDebugTokenInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugTokenInfo, deletable);
    }
};
/// <summary>
/// Variable list.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO)</para>
/// </summary>
public ref struct ShaderDebugVarInfo 
{
public:
    /// <summary>
    /// Index into token list for declaring identifier.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO.TokenId)</para>
    /// </summary>
    property UInt32 TokenId
    {
        UInt32 get()
        {
            return (nativeObject->TokenId);
        }
        void set(UInt32 value)
        {
            nativeObject->TokenId = value;
        }
    }
    /// <summary>
    /// Register and component for this variable. Type is only required for arrays.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO.Type)</para>
    /// </summary>
    property ShaderVariableType Type
    {
        ShaderVariableType get()
        {
            return (ShaderVariableType)(nativeObject->Type);
        }
        void set(ShaderVariableType value)
        {
            nativeObject->Type = (D3D10_SHADER_VARIABLE_TYPE)value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO.Register)</para>
    /// </summary>
    property UInt32 Register
    {
        UInt32 get()
        {
            return (nativeObject->Register);
        }
        void set(UInt32 value)
        {
            nativeObject->Register = value;
        }
    }
    /// <summary>
    /// The original variable that declared this variable.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO.Component)</para>
    /// </summary>
    property UInt32 Component
    {
        UInt32 get()
        {
            return (nativeObject->Component);
        }
        void set(UInt32 value)
        {
            nativeObject->Component = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO.ScopeVar)</para>
    /// </summary>
    property UInt32 ScopeVar
    {
        UInt32 get()
        {
            return (nativeObject->ScopeVar);
        }
        void set(UInt32 value)
        {
            nativeObject->ScopeVar = value;
        }
    }
    /// <summary>
    /// This variable's offset in its ScopeVar.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_VAR_INFO.ScopeVarOffset)</para>
    /// </summary>
    property UInt32 ScopeVarOffset
    {
        UInt32 get()
        {
            return (nativeObject->ScopeVarOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->ScopeVarOffset = value;
        }
    }
public:
    ShaderDebugVarInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_VAR_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_VAR_INFO> nativeObject;
internal:
    ShaderDebugVarInfo(D3D10_SHADER_DEBUG_VAR_INFO* pShaderDebugVarInfo)
    {
        nativeObject.Set(pShaderDebugVarInfo);
    }
    ShaderDebugVarInfo(D3D10_SHADER_DEBUG_VAR_INFO* pShaderDebugVarInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugVarInfo, deletable);
    }
};
/// <summary>
/// TBD
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO)</para>
/// </summary>
public ref struct ShaderDebugOutputregInfo 
{
public:
    /// <summary>
    /// Must be Temp, TempARRAY or Output.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.OutputRegisterSet)</para>
    /// </summary>
    property ShaderDebugRegisterType OutputRegisterSet
    {
        ShaderDebugRegisterType get()
        {
            return (ShaderDebugRegisterType)(nativeObject->OutputRegisterSet);
        }
        void set(ShaderDebugRegisterType value)
        {
            nativeObject->OutputRegisterSet = (D3D10_SHADER_DEBUG_REGTYPE)value;
        }
    }
    /// <summary>
    /// A value of -1 indicates no output.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.OutputReg)</para>
    /// </summary>
    property UInt32 OutputReg
    {
        UInt32 get()
        {
            return (nativeObject->OutputReg);
        }
        void set(UInt32 value)
        {
            nativeObject->OutputReg = value;
        }
    }
    /// <summary>
    /// If OutputRegisterSet is Temparray this indicates which temp array.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.TempArrayReg)</para>
    /// </summary>
    property UInt32 TempArrayReg
    {
        UInt32 get()
        {
            return (nativeObject->TempArrayReg);
        }
        void set(UInt32 value)
        {
            nativeObject->TempArrayReg = value;
        }
    }
    /// <summary>
    /// A value of -1 means the component is masked out.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.OutputComponents)</para>
    /// </summary>
    property UInt32 OutputComponents[int]
    {
        UInt32 get(int i)
        {
            if (i < 0 || i >= OutputComponentsArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            return nativeObject->OutputComponents[i];
        }

        void set(int i, UInt32 value)
        {
            if (i < 0 || i >= OutputComponentsArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            nativeObject->OutputComponents[i] = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.OutputVars)</para>
    /// </summary>
    property ShaderDebugOutputvar^ OutputVars[int]
    {
        ShaderDebugOutputvar^ get(int i)
        {
            if (i < 0 || i >= OutputVarsArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            return gcnew ShaderDebugOutputvar(&(nativeObject->OutputVars[i]), false);
        }

        void set(int i, ShaderDebugOutputvar^ value)
        {
            if (i < 0 || i >= OutputVarsArrayLength)
                throw gcnew IndexOutOfRangeException("Range is 0 to 3");
            memcpy(&(nativeObject->OutputComponents[i]), value->nativeObject.Get(), sizeof(D3D10_SHADER_DEBUG_OUTPUTVAR));
        }

    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.IndexReg)</para>
    /// </summary>
    property UInt32 IndexReg
    {
        UInt32 get()
        {
            return (nativeObject->IndexReg);
        }
        void set(UInt32 value)
        {
            nativeObject->IndexReg = value;
        }
    }
    /// <summary>
    /// TBD
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_OUTPUTREG_INFO.IndexComp)</para>
    /// </summary>
    property UInt32 IndexComp
    {
        UInt32 get()
        {
            return (nativeObject->IndexComp);
        }
        void set(UInt32 value)
        {
            nativeObject->IndexComp = value;
        }
    }
public:
    ShaderDebugOutputregInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_OUTPUTREG_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_OUTPUTREG_INFO> nativeObject;
internal:
    ShaderDebugOutputregInfo(D3D10_SHADER_DEBUG_OUTPUTREG_INFO* pShaderDebugOutputregInfo)
    {
        nativeObject.Set(pShaderDebugOutputregInfo);
    }
    ShaderDebugOutputregInfo(D3D10_SHADER_DEBUG_OUTPUTREG_INFO* pShaderDebugOutputregInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugOutputregInfo, deletable);
    }
public:
        literal int OutputComponentsArrayLength = 4;
        literal int OutputVarsArrayLength = 4;
};
/// <summary>
/// Contains instruction data.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO)</para>
/// </summary>
public ref struct ShaderDebugInstInfo 
{
public:
    /// <summary>
    /// Id of the instruction.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.Id)</para>
    /// </summary>
    property UInt32 Id
    {
        UInt32 get()
        {
            return (nativeObject->Id);
        }
        void set(UInt32 value)
        {
            nativeObject->Id = value;
        }
    }
    /// <summary>
    /// Type of instruction.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.Opcode)</para>
    /// </summary>
    property UInt32 Opcode
    {
        UInt32 get()
        {
            return (nativeObject->Opcode);
        }
        void set(UInt32 value)
        {
            nativeObject->Opcode = value;
        }
    }
    /// <summary>
    /// Must be 0, 1 or 2.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.uOutputs)</para>
    /// </summary>
    property UInt32 uOutputs
    {
        UInt32 get()
        {
            return (nativeObject->uOutputs);
        }
        void set(UInt32 value)
        {
            nativeObject->uOutputs = value;
        }
    }
    /// <summary>
    /// Array containing the outputs of the instruction.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.pOutputs)</para>
    /// </summary>
    property ShaderDebugOutputregInfo^ pOutputs[int]
    {
        ShaderDebugOutputregInfo^ get(int i)
        {
            if (i < 0 || i >= pOutputsArrayLength)
                throw gcnew IndexOutOfRangeException("Range 0 to 1");
            return gcnew ShaderDebugOutputregInfo(&(nativeObject->pOutputs[i]), false);
        }
    }
    /// <summary>
    /// Index into the collection of tokens for this instruction's token.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.TokenId)</para>
    /// </summary>
    property UInt32 TokenId
    {
        UInt32 get()
        {
            return (nativeObject->TokenId);
        }
        void set(UInt32 value)
        {
            nativeObject->TokenId = value;
        }
    }
    /// <summary>
    /// Number of function calls deep this instruction is.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.NestingLevel)</para>
    /// </summary>
    property UInt32 NestingLevel
    {
        UInt32 get()
        {
            return (nativeObject->NestingLevel);
        }
        void set(UInt32 value)
        {
            nativeObject->NestingLevel = value;
        }
    }
    /// <summary>
    /// Number of scopes.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.Scopes)</para>
    /// </summary>
    property UInt32 Scopes
    {
        UInt32 get()
        {
            return (nativeObject->Scopes);
        }
        void set(UInt32 value)
        {
            nativeObject->Scopes = value;
        }
    }
    /// <summary>
    /// Offset to an array of UINT values with Scopes elements.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DEBUG_INST_INFO.ScopeInfo)</para>
    /// </summary>
    property UInt32 ScopeInfo
    {
        UInt32 get()
        {
            return (nativeObject->ScopeInfo);
        }
        void set(UInt32 value)
        {
            nativeObject->ScopeInfo = value;
        }
    }
public:
    ShaderDebugInstInfo()
    {
        nativeObject.Set(new D3D10_SHADER_DEBUG_INST_INFO());
    }
internal:
    AutoPointer<D3D10_SHADER_DEBUG_INST_INFO> nativeObject;
internal:
    ShaderDebugInstInfo(D3D10_SHADER_DEBUG_INST_INFO* pShaderDebugInstInfo)
    {
        nativeObject.Set(pShaderDebugInstInfo);
    }
    ShaderDebugInstInfo(D3D10_SHADER_DEBUG_INST_INFO* pShaderDebugInstInfo, bool deletable)
    {
        nativeObject.Set(pShaderDebugInstInfo, deletable);
    }
public:
        literal int pOutputsArrayLength = 2;
};
/// <summary>
/// Describes a shader.
/// <para>(Also see DirectX SDK: D3D10_SHADER_DESC)</para>
/// </summary>
public ref struct ShaderDescription 
{
public:
    /// <summary>
    /// Shader version.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.Version)</para>
    /// </summary>
    property UInt32 Version
    {
        UInt32 get()
        {
            return (nativeObject->Version);
        }
        void set(UInt32 value)
        {
            nativeObject->Version = value;
        }
    }
    /// <summary>
    /// The name of the originator of the shader.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.Creator)</para>
    /// </summary>
    property String^ Creator
    {
        String^ get()
        {
            if (nativeObject->Creator == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Creator);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Creator", "Creator cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Creator = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// Shader compilation/parse flags.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.Flags)</para>
    /// </summary>
    property UInt32 Flags
    {
        UInt32 get()
        {
            return (nativeObject->Flags);
        }
        void set(UInt32 value)
        {
            nativeObject->Flags = value;
        }
    }
    /// <summary>
    /// The number of shader-constant buffers.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.ConstantBuffers)</para>
    /// </summary>
    property UInt32 ConstantBuffers
    {
        UInt32 get()
        {
            return (nativeObject->ConstantBuffers);
        }
        void set(UInt32 value)
        {
            nativeObject->ConstantBuffers = value;
        }
    }
    /// <summary>
    /// The number of resource (textures and buffers) bound to a shader.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.BoundResources)</para>
    /// </summary>
    property UInt32 BoundResources
    {
        UInt32 get()
        {
            return (nativeObject->BoundResources);
        }
        void set(UInt32 value)
        {
            nativeObject->BoundResources = value;
        }
    }
    /// <summary>
    /// The number of parameters in the input signature.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.InputParameters)</para>
    /// </summary>
    property UInt32 InputParameters
    {
        UInt32 get()
        {
            return (nativeObject->InputParameters);
        }
        void set(UInt32 value)
        {
            nativeObject->InputParameters = value;
        }
    }
    /// <summary>
    /// The number of parameters in the output signature.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.OutputParameters)</para>
    /// </summary>
    property UInt32 OutputParameters
    {
        UInt32 get()
        {
            return (nativeObject->OutputParameters);
        }
        void set(UInt32 value)
        {
            nativeObject->OutputParameters = value;
        }
    }
    /// <summary>
    /// The number of intermediate-language instructions in the compiled shader.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.InstructionCount)</para>
    /// </summary>
    property UInt32 InstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->InstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->InstructionCount = value;
        }
    }
    /// <summary>
    /// The number of temporary registers in the compiled shader.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TempRegisterCount)</para>
    /// </summary>
    property UInt32 TempRegisterCount
    {
        UInt32 get()
        {
            return (nativeObject->TempRegisterCount);
        }
        void set(UInt32 value)
        {
            nativeObject->TempRegisterCount = value;
        }
    }
    /// <summary>
    /// Number of temporary arrays used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TempArrayCount)</para>
    /// </summary>
    property UInt32 TempArrayCount
    {
        UInt32 get()
        {
            return (nativeObject->TempArrayCount);
        }
        void set(UInt32 value)
        {
            nativeObject->TempArrayCount = value;
        }
    }
    /// <summary>
    /// Number of constant defines.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.DefCount)</para>
    /// </summary>
    property UInt32 DefCount
    {
        UInt32 get()
        {
            return (nativeObject->DefCount);
        }
        void set(UInt32 value)
        {
            nativeObject->DefCount = value;
        }
    }
    /// <summary>
    /// Number of declarations (input + output).
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.DclCount)</para>
    /// </summary>
    property UInt32 DclCount
    {
        UInt32 get()
        {
            return (nativeObject->DclCount);
        }
        void set(UInt32 value)
        {
            nativeObject->DclCount = value;
        }
    }
    /// <summary>
    /// Number of non-categorized texture instructions.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TextureNormalInstructions)</para>
    /// </summary>
    property UInt32 TextureNormalInstructions
    {
        UInt32 get()
        {
            return (nativeObject->TextureNormalInstructions);
        }
        void set(UInt32 value)
        {
            nativeObject->TextureNormalInstructions = value;
        }
    }
    /// <summary>
    /// Number of texture load instructions
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TextureLoadInstructions)</para>
    /// </summary>
    property UInt32 TextureLoadInstructions
    {
        UInt32 get()
        {
            return (nativeObject->TextureLoadInstructions);
        }
        void set(UInt32 value)
        {
            nativeObject->TextureLoadInstructions = value;
        }
    }
    /// <summary>
    /// Number of texture comparison instructions
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TextureCompInstructions)</para>
    /// </summary>
    property UInt32 TextureCompInstructions
    {
        UInt32 get()
        {
            return (nativeObject->TextureCompInstructions);
        }
        void set(UInt32 value)
        {
            nativeObject->TextureCompInstructions = value;
        }
    }
    /// <summary>
    /// Number of texture bias instructions
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TextureBiasInstructions)</para>
    /// </summary>
    property UInt32 TextureBiasInstructions
    {
        UInt32 get()
        {
            return (nativeObject->TextureBiasInstructions);
        }
        void set(UInt32 value)
        {
            nativeObject->TextureBiasInstructions = value;
        }
    }
    /// <summary>
    /// Number of texture gradient instructions.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.TextureGradientInstructions)</para>
    /// </summary>
    property UInt32 TextureGradientInstructions
    {
        UInt32 get()
        {
            return (nativeObject->TextureGradientInstructions);
        }
        void set(UInt32 value)
        {
            nativeObject->TextureGradientInstructions = value;
        }
    }
    /// <summary>
    /// Number of floating point arithmetic instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.FloatInstructionCount)</para>
    /// </summary>
    property UInt32 FloatInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->FloatInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->FloatInstructionCount = value;
        }
    }
    /// <summary>
    /// Number of signed integer arithmetic instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.IntInstructionCount)</para>
    /// </summary>
    property UInt32 IntInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->IntInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->IntInstructionCount = value;
        }
    }
    /// <summary>
    /// Number of unsigned integer arithmetic instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.UintInstructionCount)</para>
    /// </summary>
    property UInt32 UintInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->UintInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->UintInstructionCount = value;
        }
    }
    /// <summary>
    /// Number of static flow control instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.StaticFlowControlCount)</para>
    /// </summary>
    property UInt32 StaticFlowControlCount
    {
        UInt32 get()
        {
            return (nativeObject->StaticFlowControlCount);
        }
        void set(UInt32 value)
        {
            nativeObject->StaticFlowControlCount = value;
        }
    }
    /// <summary>
    /// Number of dynamic flow control instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.DynamicFlowControlCount)</para>
    /// </summary>
    property UInt32 DynamicFlowControlCount
    {
        UInt32 get()
        {
            return (nativeObject->DynamicFlowControlCount);
        }
        void set(UInt32 value)
        {
            nativeObject->DynamicFlowControlCount = value;
        }
    }
    /// <summary>
    /// Number of macro instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.MacroInstructionCount)</para>
    /// </summary>
    property UInt32 MacroInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->MacroInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->MacroInstructionCount = value;
        }
    }
    /// <summary>
    /// Number of array instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.ArrayInstructionCount)</para>
    /// </summary>
    property UInt32 ArrayInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->ArrayInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->ArrayInstructionCount = value;
        }
    }
    /// <summary>
    /// Number of cut instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.CutInstructionCount)</para>
    /// </summary>
    property UInt32 CutInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->CutInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->CutInstructionCount = value;
        }
    }
    /// <summary>
    /// Number of emit instructions used.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.EmitInstructionCount)</para>
    /// </summary>
    property UInt32 EmitInstructionCount
    {
        UInt32 get()
        {
            return (nativeObject->EmitInstructionCount);
        }
        void set(UInt32 value)
        {
            nativeObject->EmitInstructionCount = value;
        }
    }
    /// <summary>
    /// Geometry shader output topology.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.GSOutputTopology)</para>
    /// </summary>
    property PrimitiveTopology GSOutputTopology
    {
        PrimitiveTopology get()
        {
            return (PrimitiveTopology)(nativeObject->GSOutputTopology);
        }
        void set(PrimitiveTopology value)
        {
            nativeObject->GSOutputTopology = (D3D10_PRIMITIVE_TOPOLOGY)value;
        }
    }
    /// <summary>
    /// Geometry shader maximum output vertex count.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_DESC.GSMaxOutputVertexCount)</para>
    /// </summary>
    property UInt32 GSMaxOutputVertexCount
    {
        UInt32 get()
        {
            return (nativeObject->GSMaxOutputVertexCount);
        }
        void set(UInt32 value)
        {
            nativeObject->GSMaxOutputVertexCount = value;
        }
    }
public:
    ShaderDescription()
    {
        nativeObject.Set(new D3D10_SHADER_DESC());
    }
internal:
    AutoPointer<D3D10_SHADER_DESC> nativeObject;
internal:
    ShaderDescription(D3D10_SHADER_DESC* pShaderDescription)
    {
        nativeObject.Set(pShaderDescription);
    }
    ShaderDescription(D3D10_SHADER_DESC* pShaderDescription, bool deletable)
    {
        nativeObject.Set(pShaderDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Describes how a shader resource is bound to a shader input.
/// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC)</para>
/// </summary>
public ref struct ShaderInputBindDescription 
{
public:
    /// <summary>
    /// Name of the shader resource.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// Identifies the type of data in the resource. See ShaderInputType.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.Type)</para>
    /// </summary>
    property ShaderInputType Type
    {
        ShaderInputType get()
        {
            return (ShaderInputType)(nativeObject->Type);
        }
        void set(ShaderInputType value)
        {
            nativeObject->Type = (D3D10_SHADER_INPUT_TYPE)value;
        }
    }
    /// <summary>
    /// Starting bind point.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.BindPoint)</para>
    /// </summary>
    property UInt32 BindPoint
    {
        UInt32 get()
        {
            return (nativeObject->BindPoint);
        }
        void set(UInt32 value)
        {
            nativeObject->BindPoint = value;
        }
    }
    /// <summary>
    /// Number of contiguous bind points for arrays.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.BindCount)</para>
    /// </summary>
    property UInt32 BindCount
    {
        UInt32 get()
        {
            return (nativeObject->BindCount);
        }
        void set(UInt32 value)
        {
            nativeObject->BindCount = value;
        }
    }
    /// <summary>
    /// Shader input-parameter options. See ShaderInputFlags.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.uFlags)</para>
    /// </summary>
    property UInt32 uFlags
    {
        UInt32 get()
        {
            return (nativeObject->uFlags);
        }
        void set(UInt32 value)
        {
            nativeObject->uFlags = value;
        }
    }
    /// <summary>
    /// If the input is a texture, the return type. See ResourceReturnType.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.ReturnType)</para>
    /// </summary>
    property ResourceReturnType ReturnType
    {
        ResourceReturnType get()
        {
            return (ResourceReturnType)(nativeObject->ReturnType);
        }
        void set(ResourceReturnType value)
        {
            nativeObject->ReturnType = (D3D10_RESOURCE_RETURN_TYPE)value;
        }
    }
    /// <summary>
    /// Identifies the amount of data in the resource. See ShaderResourceViewDimension.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.Dimension)</para>
    /// </summary>
    property ShaderResourceViewDimension Dimension
    {
        ShaderResourceViewDimension get()
        {
            return (ShaderResourceViewDimension)(nativeObject->Dimension);
        }
        void set(ShaderResourceViewDimension value)
        {
            nativeObject->Dimension = (D3D10_SRV_DIMENSION)value;
        }
    }
    /// <summary>
    /// The number of samples for a multisampled texture; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_INPUT_BIND_DESC.NumSamples)</para>
    /// </summary>
    property UInt32 NumSamples
    {
        UInt32 get()
        {
            return (nativeObject->NumSamples);
        }
        void set(UInt32 value)
        {
            nativeObject->NumSamples = value;
        }
    }
public:
    ShaderInputBindDescription()
    {
        nativeObject.Set(new D3D10_SHADER_INPUT_BIND_DESC());
    }
internal:
    AutoPointer<D3D10_SHADER_INPUT_BIND_DESC> nativeObject;
internal:
    ShaderInputBindDescription(D3D10_SHADER_INPUT_BIND_DESC* pShaderInputBindDescription)
    {
        nativeObject.Set(pShaderInputBindDescription);
    }
    ShaderInputBindDescription(D3D10_SHADER_INPUT_BIND_DESC* pShaderInputBindDescription, bool deletable)
    {
        nativeObject.Set(pShaderInputBindDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Defines a shader macro.
/// <para>(Also see DirectX SDK: D3D10_SHADER_MACRO)</para>
/// </summary>
public ref struct ShaderMacro 
{
public:
    /// <summary>
    /// The macro name.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_MACRO.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The macro definition.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_MACRO.Definition)</para>
    /// </summary>
    property String^ Definition
    {
        String^ get()
        {
            if (nativeObject->Definition == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Definition);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Definition", "Definition cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Definition = context->marshal_as<const char*>(value);
        }
    }
public:
    ShaderMacro()
    {
        nativeObject.Set(new D3D10_SHADER_MACRO());
    }
internal:
    AutoPointer<D3D10_SHADER_MACRO> nativeObject;
internal:
    ShaderMacro(D3D10_SHADER_MACRO* pShaderMacro)
    {
        nativeObject.Set(pShaderMacro);
    }
    ShaderMacro(D3D10_SHADER_MACRO* pShaderMacro, bool deletable)
    {
        nativeObject.Set(pShaderMacro, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Describes a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC)</para>
/// </summary>
public ref struct ShaderResourceViewDescription 
{
public:
    /// <summary>
    /// The viewing format.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// The resource type of the view. See ShaderResourceViewDimension. This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.ViewDimension)</para>
    /// </summary>
    property ShaderResourceViewDimension ViewDimension
    {
        ShaderResourceViewDimension get()
        {
            return (ShaderResourceViewDimension)(nativeObject->ViewDimension);
        }
        void set(ShaderResourceViewDimension value)
        {
            nativeObject->ViewDimension = (D3D10_SRV_DIMENSION)value;
        }
    }
    /// <summary>
    /// View the resource as a buffer using information from a shader-resource view (see <see cref="BufferShaderResourceView"/>)<seealso cref="BufferShaderResourceView"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Buffer)</para>
    /// </summary>
    property BufferShaderResourceView^ Buffer
    {
        BufferShaderResourceView^ get()
        {
            return gcnew BufferShaderResourceView(&(nativeObject->Buffer), false);
        }
        void set(BufferShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Buffer), (void*)(value->nativeObject.Get()), sizeof(D3D10_BUFFER_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 1D texture using information from a shader-resource view (see <see cref="Texture1dShaderResourceView"/>)<seealso cref="Texture1dShaderResourceView"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture1D)</para>
    /// </summary>
    property Texture1dShaderResourceView^ Texture1d
    {
        Texture1dShaderResourceView^ get()
        {
            return gcnew Texture1dShaderResourceView(&(nativeObject->Texture1D), false);
        }
        void set(Texture1dShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture1D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 1D-texture array using information from a shader-resource view (see Texture1dArrayShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture1dArray)</para>
    /// </summary>
    property Texture1dArrayShaderResourceView^ Texture1dArray
    {
        Texture1dArrayShaderResourceView^ get()
        {
            return gcnew Texture1dArrayShaderResourceView(&(nativeObject->Texture1DArray), false);
        }
        void set(Texture1dArrayShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture1DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_ARRAY_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-texture using information from a shader-resource view (see Texture2dShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture2D)</para>
    /// </summary>
    property Texture2dShaderResourceView^ Texture2d
    {
        Texture2dShaderResourceView^ get()
        {
            return gcnew Texture2dShaderResourceView(&(nativeObject->Texture2D), false);
        }
        void set(Texture2dShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-texture array using information from a shader-resource view (see Texture2dArrayShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture2dArray)</para>
    /// </summary>
    property Texture2dArrayShaderResourceView^ Texture2dArray
    {
        Texture2dArrayShaderResourceView^ get()
        {
            return gcnew Texture2dArrayShaderResourceView(&(nativeObject->Texture2DArray), false);
        }
        void set(Texture2dArrayShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_ARRAY_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-multisampled texture using information from a shader-resource view (see Texture2dMultiSampleShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture2dMultiSample)</para>
    /// </summary>
    property Texture2dMultiSampleShaderResourceView^ Texture2dMultiSample
    {
        Texture2dMultiSampleShaderResourceView^ get()
        {
            return gcnew Texture2dMultiSampleShaderResourceView(&(nativeObject->Texture2DMS), false);
        }
        void set(Texture2dMultiSampleShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2DMS), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see Texture2dMultiSampleArrayShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture2DMSArray)</para>
    /// </summary>
    property Texture2dMultiSampleArrayShaderResourceView^ Texture2dMSArray
    {
        Texture2dMultiSampleArrayShaderResourceView^ get()
        {
            return gcnew Texture2dMultiSampleArrayShaderResourceView(&(nativeObject->Texture2DMSArray), false);
        }
        void set(Texture2dMultiSampleArrayShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2DMSArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_ARRAY_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 3D texture using information from a shader-resource view (see Texture3dShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.Texture3D)</para>
    /// </summary>
    property Texture3dShaderResourceView^ Texture3d
    {
        Texture3dShaderResourceView^ get()
        {
            return gcnew Texture3dShaderResourceView(&(nativeObject->Texture3D), false);
        }
        void set(Texture3dShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture3D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX3D_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 3D-cube texture using information from a shader-resource view (see <see cref="TextureCubeShaderResourceView"/>)<seealso cref="TextureCubeShaderResourceView"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC.TextureCube)</para>
    /// </summary>
    property TextureCubeShaderResourceView^ TextureCube
    {
        TextureCubeShaderResourceView^ get()
        {
            return gcnew TextureCubeShaderResourceView(&(nativeObject->TextureCube), false);
        }
        void set(TextureCubeShaderResourceView^ value)
        {
            memcpy(&(nativeObject->TextureCube), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEXCUBE_SRV));
        }
    }
public:
    ShaderResourceViewDescription()
    {
        nativeObject.Set(new D3D10_SHADER_RESOURCE_VIEW_DESC());
    }
internal:
    AutoPointer<D3D10_SHADER_RESOURCE_VIEW_DESC> nativeObject;
internal:
    ShaderResourceViewDescription(D3D10_SHADER_RESOURCE_VIEW_DESC* pShaderResourceViewDescription)
    {
        nativeObject.Set(pShaderResourceViewDescription);
    }
    ShaderResourceViewDescription(D3D10_SHADER_RESOURCE_VIEW_DESC* pShaderResourceViewDescription, bool deletable)
    {
        nativeObject.Set(pShaderResourceViewDescription, deletable);
    }
};
/// <summary>
/// Describes a shader-resource view.
/// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1)</para>
/// </summary>
public ref struct ShaderResourceViewDescription1 
{
public:
    /// <summary>
    /// The viewing format.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Format)</para>
    /// </summary>
    property DXGI::Format Format
    {
        DXGI::Format get()
        {
            return (DXGI::Format)(nativeObject->Format);
        }
        void set(DXGI::Format value)
        {
            nativeObject->Format = (DXGI_FORMAT)value;
        }
    }
    /// <summary>
    /// The resource type of the view. See ShaderResourceViewDimension1. This should be the same as the resource type of the underlying resource. This parameter also determines which _SRV to use in the union below.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.ViewDimension)</para>
    /// </summary>
    property ShaderResourceViewDimension1 ViewDimension
    {
        ShaderResourceViewDimension1 get()
        {
            return (ShaderResourceViewDimension1)(nativeObject->ViewDimension);
        }
        void set(ShaderResourceViewDimension1 value)
        {
            nativeObject->ViewDimension = (D3D10_SRV_DIMENSION1)value;
        }
    }
    /// <summary>
    /// View the resource as a buffer using information from a shader-resource view (see <see cref="BufferShaderResourceView"/>)<seealso cref="BufferShaderResourceView"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Buffer)</para>
    /// </summary>
    property BufferShaderResourceView^ Buffer
    {
        BufferShaderResourceView^ get()
        {
            return gcnew BufferShaderResourceView(&(nativeObject->Buffer), false);
        }
        void set(BufferShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Buffer), (void*)(value->nativeObject.Get()), sizeof(D3D10_BUFFER_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 1D texture using information from a shader-resource view (see <see cref="Texture1dShaderResourceView"/>)<seealso cref="Texture1dShaderResourceView"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture1D)</para>
    /// </summary>
    property Texture1dShaderResourceView^ Texture1d
    {
        Texture1dShaderResourceView^ get()
        {
            return gcnew Texture1dShaderResourceView(&(nativeObject->Texture1D), false);
        }
        void set(Texture1dShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture1D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 1D-texture array using information from a shader-resource view (see Texture1dArrayShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture1dArray)</para>
    /// </summary>
    property Texture1dArrayShaderResourceView^ Texture1dArray
    {
        Texture1dArrayShaderResourceView^ get()
        {
            return gcnew Texture1dArrayShaderResourceView(&(nativeObject->Texture1DArray), false);
        }
        void set(Texture1dArrayShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture1DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX1D_ARRAY_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-texture using information from a shader-resource view (see Texture2dShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture2D)</para>
    /// </summary>
    property Texture2dShaderResourceView^ Texture2d
    {
        Texture2dShaderResourceView^ get()
        {
            return gcnew Texture2dShaderResourceView(&(nativeObject->Texture2D), false);
        }
        void set(Texture2dShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-texture array using information from a shader-resource view (see Texture2dArrayShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture2dArray)</para>
    /// </summary>
    property Texture2dArrayShaderResourceView^ Texture2dArray
    {
        Texture2dArrayShaderResourceView^ get()
        {
            return gcnew Texture2dArrayShaderResourceView(&(nativeObject->Texture2DArray), false);
        }
        void set(Texture2dArrayShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2DArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2D_ARRAY_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-multisampled texture using information from a shader-resource view (see Texture2dMultiSampleShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture2dMultiSample)</para>
    /// </summary>
    property Texture2dMultiSampleShaderResourceView^ Texture2dMultiSample
    {
        Texture2dMultiSampleShaderResourceView^ get()
        {
            return gcnew Texture2dMultiSampleShaderResourceView(&(nativeObject->Texture2DMS), false);
        }
        void set(Texture2dMultiSampleShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2DMS), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 2D-multisampled-texture array using information from a shader-resource view (see Texture2dMultiSampleArrayShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture2DMSArray)</para>
    /// </summary>
    property Texture2dMultiSampleArrayShaderResourceView^ Texture2dMSArray
    {
        Texture2dMultiSampleArrayShaderResourceView^ get()
        {
            return gcnew Texture2dMultiSampleArrayShaderResourceView(&(nativeObject->Texture2DMSArray), false);
        }
        void set(Texture2dMultiSampleArrayShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture2DMSArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX2DMS_ARRAY_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 3D texture using information from a shader-resource view (see Texture3dShaderResourceView.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.Texture3D)</para>
    /// </summary>
    property Texture3dShaderResourceView^ Texture3d
    {
        Texture3dShaderResourceView^ get()
        {
            return gcnew Texture3dShaderResourceView(&(nativeObject->Texture3D), false);
        }
        void set(Texture3dShaderResourceView^ value)
        {
            memcpy(&(nativeObject->Texture3D), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEX3D_SRV));
        }
    }
    /// <summary>
    /// View the resource as a 3D-cube texture using information from a shader-resource view (see <see cref="TextureCubeShaderResourceView"/>)<seealso cref="TextureCubeShaderResourceView"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.TextureCube)</para>
    /// </summary>
    property TextureCubeShaderResourceView^ TextureCube
    {
        TextureCubeShaderResourceView^ get()
        {
            return gcnew TextureCubeShaderResourceView(&(nativeObject->TextureCube), false);
        }
        void set(TextureCubeShaderResourceView^ value)
        {
            memcpy(&(nativeObject->TextureCube), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEXCUBE_SRV));
        }
    }
    /// <summary>
    /// View the resource as an array of cube textures using information from a shader-resource view (see <see cref="TextureCubeArrayShaderResourceView1"/>)<seealso cref="TextureCubeArrayShaderResourceView1"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_RESOURCE_VIEW_DESC1.TextureCubeArray)</para>
    /// </summary>
    property TextureCubeArrayShaderResourceView1^ TextureCubeArray
    {
        TextureCubeArrayShaderResourceView1^ get()
        {
            return gcnew TextureCubeArrayShaderResourceView1(&(nativeObject->TextureCubeArray), false);
        }
        void set(TextureCubeArrayShaderResourceView1^ value)
        {
            memcpy(&(nativeObject->TextureCubeArray), (void*)(value->nativeObject.Get()), sizeof(D3D10_TEXCUBE_ARRAY_SRV1));
        }
    }
public:
    ShaderResourceViewDescription1()
    {
        nativeObject.Set(new D3D10_SHADER_RESOURCE_VIEW_DESC1());
    }
internal:
    AutoPointer<D3D10_SHADER_RESOURCE_VIEW_DESC1> nativeObject;
internal:
    ShaderResourceViewDescription1(D3D10_SHADER_RESOURCE_VIEW_DESC1* pShaderResourceViewDescription1)
    {
        nativeObject.Set(pShaderResourceViewDescription1);
    }
    ShaderResourceViewDescription1(D3D10_SHADER_RESOURCE_VIEW_DESC1* pShaderResourceViewDescription1, bool deletable)
    {
        nativeObject.Set(pShaderResourceViewDescription1, deletable);
    }
};
/// <summary>
/// Describes a shader-variable type.
/// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC)</para>
/// </summary>
public ref struct ShaderTypeDescription 
{
public:
    /// <summary>
    /// Identifies the variable class as one of scalar, vector, matrix or object. See ShaderVariableClass.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Class)</para>
    /// </summary>
    property ShaderVariableClass Class
    {
        ShaderVariableClass get()
        {
            return (ShaderVariableClass)(nativeObject->Class);
        }
        void set(ShaderVariableClass value)
        {
            nativeObject->Class = (D3D10_SHADER_VARIABLE_CLASS)value;
        }
    }
    /// <summary>
    /// The variable type. See ShaderVariableType.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Type)</para>
    /// </summary>
    property ShaderVariableType Type
    {
        ShaderVariableType get()
        {
            return (ShaderVariableType)(nativeObject->Type);
        }
        void set(ShaderVariableType value)
        {
            nativeObject->Type = (D3D10_SHADER_VARIABLE_TYPE)value;
        }
    }
    /// <summary>
    /// Number of rows in a matrix. Otherwise a numeric type returns 1, any other type returns 0.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Rows)</para>
    /// </summary>
    property UInt32 Rows
    {
        UInt32 get()
        {
            return (nativeObject->Rows);
        }
        void set(UInt32 value)
        {
            nativeObject->Rows = value;
        }
    }
    /// <summary>
    /// Number of columns in a matrix. Otherwise a numeric type returns 1, any other type returns 0.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Columns)</para>
    /// </summary>
    property UInt32 Columns
    {
        UInt32 get()
        {
            return (nativeObject->Columns);
        }
        void set(UInt32 value)
        {
            nativeObject->Columns = value;
        }
    }
    /// <summary>
    /// Number of elements in an array; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Elements)</para>
    /// </summary>
    property UInt32 Elements
    {
        UInt32 get()
        {
            return (nativeObject->Elements);
        }
        void set(UInt32 value)
        {
            nativeObject->Elements = value;
        }
    }
    /// <summary>
    /// Number of members in the structure; otherwise 0.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Members)</para>
    /// </summary>
    property UInt32 Members
    {
        UInt32 get()
        {
            return (nativeObject->Members);
        }
        void set(UInt32 value)
        {
            nativeObject->Members = value;
        }
    }
    /// <summary>
    /// Offset, in bytes, between the start of the parent structure and this variable.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_TYPE_DESC.Offset)</para>
    /// </summary>
    property UInt32 Offset
    {
        UInt32 get()
        {
            return (nativeObject->Offset);
        }
        void set(UInt32 value)
        {
            nativeObject->Offset = value;
        }
    }
public:
    ShaderTypeDescription()
    {
        nativeObject.Set(new D3D10_SHADER_TYPE_DESC());
    }
internal:
    AutoPointer<D3D10_SHADER_TYPE_DESC> nativeObject;
internal:
    ShaderTypeDescription(D3D10_SHADER_TYPE_DESC* pShaderTypeDescription)
    {
        nativeObject.Set(pShaderTypeDescription);
    }
    ShaderTypeDescription(D3D10_SHADER_TYPE_DESC* pShaderTypeDescription, bool deletable)
    {
        nativeObject.Set(pShaderTypeDescription, deletable);
    }
};
/// <summary>
/// Describes a shader variable.
/// <para>(Also see DirectX SDK: D3D10_SHADER_VARIABLE_DESC)</para>
/// </summary>
public ref struct ShaderVariableDescription 
{
public:
    /// <summary>
    /// The variable name.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_VARIABLE_DESC.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// Offset from the start of the parent structure, to the beginning of the variable.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_VARIABLE_DESC.StartOffset)</para>
    /// </summary>
    property UInt32 StartOffset
    {
        UInt32 get()
        {
            return (nativeObject->StartOffset);
        }
        void set(UInt32 value)
        {
            nativeObject->StartOffset = value;
        }
    }
    /// <summary>
    /// Size of the variable (in bytes).
    /// <para>(Also see DirectX SDK: D3D10_SHADER_VARIABLE_DESC.Size)</para>
    /// </summary>
    property UInt32 Size
    {
        UInt32 get()
        {
            return (nativeObject->Size);
        }
        void set(UInt32 value)
        {
            nativeObject->Size = value;
        }
    }
    /// <summary>
    /// Flags, which identify shader-variable properties (see <see cref="ShaderVariableFlags"/>)<seealso cref="ShaderVariableFlags"/>.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_VARIABLE_DESC.uFlags)</para>
    /// </summary>
    property UInt32 uFlags
    {
        UInt32 get()
        {
            return (nativeObject->uFlags);
        }
        void set(UInt32 value)
        {
            nativeObject->uFlags = value;
        }
    }
    /// <summary>
    /// The default value for initializing the variable.
    /// <para>(Also see DirectX SDK: D3D10_SHADER_VARIABLE_DESC.DefaultValue)</para>
    /// </summary>
    property IntPtr DefaultValue
    {
        IntPtr get()
        {
            return IntPtr(nativeObject->DefaultValue);
        }

        void set(IntPtr value)
        {
            nativeObject->DefaultValue = value.ToPointer();
        }
    }

public:
    ShaderVariableDescription()
    {
        nativeObject.Set(new D3D10_SHADER_VARIABLE_DESC());
    }
internal:
    AutoPointer<D3D10_SHADER_VARIABLE_DESC> nativeObject;
internal:
    ShaderVariableDescription(D3D10_SHADER_VARIABLE_DESC* pShaderVariableDescription)
    {
        nativeObject.Set(pShaderVariableDescription);
    }
    ShaderVariableDescription(D3D10_SHADER_VARIABLE_DESC* pShaderVariableDescription, bool deletable)
    {
        nativeObject.Set(pShaderVariableDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Describes a shader signature.
/// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC)</para>
/// </summary>
public ref struct SignatureParameterDescription 
{
public:
    /// <summary>
    /// A per-parameter string that identifies how the data will be used. See Semantics (DirectX HLSL).
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.SemanticName)</para>
    /// </summary>
    property String^ SemanticName
    {
        String^ get()
        {
            if (nativeObject->SemanticName == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->SemanticName);
        }
        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("SemanticName", "SemanticName cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->SemanticName = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// Semantic index that modifies the semantic. Used to differentiate different parameters that use the same semantic.
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.SemanticIndex)</para>
    /// </summary>
    property UInt32 SemanticIndex
    {
        UInt32 get()
        {
            return (nativeObject->SemanticIndex);
        }
        void set(UInt32 value)
        {
            nativeObject->SemanticIndex = value;
        }
    }
    /// <summary>
    /// The register that will contain this variable's data.
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.Register)</para>
    /// </summary>
    property UInt32 Register
    {
        UInt32 get()
        {
            return (nativeObject->Register);
        }
        void set(UInt32 value)
        {
            nativeObject->Register = value;
        }
    }
    /// <summary>
    /// A predefined string that determines the functionality of certain pipeline stages. See Name.
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.SystemValueType)</para>
    /// </summary>
    property Name SystemValueType
    {
        Name get()
        {
            return (Name)(nativeObject->SystemValueType);
        }
        void set(Name value)
        {
            nativeObject->SystemValueType = (D3D10_NAME)value;
        }
    }
    /// <summary>
    /// The per-component-data type that is stored in a register. See RegisterComponentType. Each register can store up to four-components of data.
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.ComponentType)</para>
    /// </summary>
    property RegisterComponentType ComponentType
    {
        RegisterComponentType get()
        {
            return (RegisterComponentType)(nativeObject->ComponentType);
        }
        void set(RegisterComponentType value)
        {
            nativeObject->ComponentType = (D3D10_REGISTER_COMPONENT_TYPE)value;
        }
    }
    /// <summary>
    /// Mask which indicates which components of a register are used.
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.Mask)</para>
    /// </summary>
    property SByte Mask
    {
        SByte get()
        {
            return (SByte)(nativeObject->Mask);
        }
        void set(SByte value)
        {
            nativeObject->Mask = (BYTE)value;
        }
    }
    /// <summary>
    /// Mask which indicates whether a given component is never written (if the signature is an output signature) or always read (if the signature is an input signature). The mask is a combination of RegisterComponentType values.
    /// <para>(Also see DirectX SDK: D3D10_SIGNATURE_PARAMETER_DESC.ReadWriteMask)</para>
    /// </summary>
    property SByte ReadWriteMask
    {
        SByte get()
        {
            return (SByte)(nativeObject->ReadWriteMask);
        }
        void set(SByte value)
        {
            nativeObject->ReadWriteMask = (BYTE)value;
        }
    }
public:
    SignatureParameterDescription()
    {
        nativeObject.Set(new D3D10_SIGNATURE_PARAMETER_DESC());
    }
internal:
    AutoPointer<D3D10_SIGNATURE_PARAMETER_DESC> nativeObject;
internal:
    SignatureParameterDescription(D3D10_SIGNATURE_PARAMETER_DESC* pSignatureParameterDescription)
    {
        nativeObject.Set(pSignatureParameterDescription);
    }
    SignatureParameterDescription(D3D10_SIGNATURE_PARAMETER_DESC* pSignatureParameterDescription, bool deletable)
    {
        nativeObject.Set(pSignatureParameterDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Description of a vertex element in a vertex buffer in an output slot.
/// <para>(Also see DirectX SDK: D3D10_SO_DECLARATION_ENTRY)</para>
/// </summary>
public ref struct SoDeclarationEntry 
{
public:
    /// <summary>
    /// Type of output element.  Possible values: L"POSITION", L"NORMAL", or L"TEXCOORD0".
    /// <para>(Also see DirectX SDK: D3D10_SO_DECLARATION_ENTRY.SemanticName)</para>
    /// </summary>
    property String^ SemanticName
    {
        String^ get()
        {
            if (nativeObject->SemanticName == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->SemanticName);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("SemanticName", "SemanticName cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->SemanticName = context->marshal_as<const char*>(value);
        }    
    }
    /// <summary>
    /// Output element's zero-based index. Should be used if, for example, you have more than one texture coordinate stored in each vertex.
    /// <para>(Also see DirectX SDK: D3D10_SO_DECLARATION_ENTRY.SemanticIndex)</para>
    /// </summary>
    property UInt32 SemanticIndex
    {
        UInt32 get()
        {
            return (nativeObject->SemanticIndex);
        }
        void set(UInt32 value)
        {
            nativeObject->SemanticIndex = value;
        }
    }
    /// <summary>
    /// Which component of the entry to begin writing out to. Valid values are 0 ~ 3. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2.
    /// <para>(Also see DirectX SDK: D3D10_SO_DECLARATION_ENTRY.StartComponent)</para>
    /// </summary>
    property SByte StartComponent
    {
        SByte get()
        {
            return (SByte)(nativeObject->StartComponent);
        }
        void set(SByte value)
        {
            nativeObject->StartComponent = (BYTE)value;
        }
    }
    /// <summary>
    /// The number of components of the entry to write out to. Valid values are 1 ~ 4. For example, if you only wish to output to the y and z components of a position, then StartComponent should be 1 and ComponentCount should be 2.
    /// <para>(Also see DirectX SDK: D3D10_SO_DECLARATION_ENTRY.ComponentCount)</para>
    /// </summary>
    property SByte ComponentCount
    {
        SByte get()
        {
            return (SByte)(nativeObject->ComponentCount);
        }
        void set(SByte value)
        {
            nativeObject->ComponentCount = (BYTE)value;
        }
    }
    /// <summary>
    /// The output slot that contains the vertex buffer that contains this output entry.
    /// <para>(Also see DirectX SDK: D3D10_SO_DECLARATION_ENTRY.OutputSlot)</para>
    /// </summary>
    property SByte OutputSlot
    {
        SByte get()
        {
            return (SByte)(nativeObject->OutputSlot);
        }
        void set(SByte value)
        {
            nativeObject->OutputSlot = (BYTE)value;
        }
    }
public:
    SoDeclarationEntry()
    {
        nativeObject.Set(new D3D10_SO_DECLARATION_ENTRY());
    }
internal:
    AutoPointer<D3D10_SO_DECLARATION_ENTRY> nativeObject;
internal:
    SoDeclarationEntry(D3D10_SO_DECLARATION_ENTRY* pSoDeclarationEntry)
    {
        nativeObject.Set(pSoDeclarationEntry);
    }
    SoDeclarationEntry(D3D10_SO_DECLARATION_ENTRY* pSoDeclarationEntry, bool deletable)
    {
        nativeObject.Set(pSoDeclarationEntry, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Indicates the device state.
/// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK)</para>
/// </summary>
public ref struct StateBlockMask 
{
public:
    /// <summary>
    /// Boolean value indicating whether to save the vertex shader state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.VS)</para>
    /// </summary>
    property SByte VS
    {
        SByte get()
        {
            return (SByte)(nativeObject->VS);
        }
        void set(SByte value)
        {
            nativeObject->VS = (BYTE)value;
        }
    }
    /// <summary>
    /// Array of vertex-shader samplers.  The array is a multi-byte bitmask where each bit represents one sampler slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.VSSamplers)</para>
    /// </summary>
    property array<SByte>^ VSSamplers
    {
        array<SByte>^ get()
        {
            if (VSSamplersArray == nullptr)
            {
                VSSamplersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT));
                for (int i=0; i < VSSamplersArray->Length; i++)
                {
                    VSSamplersArray[i] = nativeObject->VSSamplers[i];
                }
            }
            return VSSamplersArray;
        }
    }
    /// <summary>
    /// Array of vertex-shader resources. The array is a multi-byte bitmask where each bit represents one resource slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.VSShaderResources)</para>
    /// </summary>
    property array<SByte>^ VSShaderResources
    {
        array<SByte>^ get()
        {
            if (VSShaderResourcesArray == nullptr)
            {
                VSShaderResourcesArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT));
                for (int i=0; i < VSShaderResourcesArray->Length; i++)
                {
                    VSShaderResourcesArray[i] = nativeObject->VSShaderResources[i];
                }
            }
            return VSShaderResourcesArray;
        }
    }
    /// <summary>
    /// Array of vertex-shader constant buffers. The array is a multi-byte bitmask where each bit represents one constant buffer slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.VSConstantBuffers)</para>
    /// </summary>
    property array<SByte>^ VSConstantBuffers
    {
        array<SByte>^ get()
        {
            if (VSConstantBuffersArray == nullptr)
            {
                VSConstantBuffersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT));
                for (int i=0; i < VSConstantBuffersArray->Length; i++)
                {
                    VSConstantBuffersArray[i] = nativeObject->VSConstantBuffers[i];
                }
            }
            return VSConstantBuffersArray;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the geometry shader state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.GS)</para>
    /// </summary>
    property SByte GS
    {
        SByte get()
        {
            return (SByte)(nativeObject->GS);
        }
        void set(SByte value)
        {
            nativeObject->GS = (BYTE)value;
        }
    }
    /// <summary>
    /// Array of geometry-shader samplers. The array is a multi-byte bitmask where each bit represents one sampler slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.GSSamplers)</para>
    /// </summary>
    property array<SByte>^ GSSamplers
    {
        array<SByte>^ get()
        {
            if (GSSamplersArray == nullptr)
            {
                GSSamplersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT));
                for (int i=0; i < GSSamplersArray->Length; i++)
                {
                    GSSamplersArray[i] = nativeObject->GSSamplers[i];
                }
            }
            return GSSamplersArray;
        }
    }
    /// <summary>
    /// Array of geometry-shader resources. The array is a multi-byte bitmask where each bit represents one resource slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.GSShaderResources)</para>
    /// </summary>
    property array<SByte>^ GSShaderResources
    {
        array<SByte>^ get()
        {
            if (GSShaderResourcesArray == nullptr)
            {
                GSShaderResourcesArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT));
                for (int i=0; i < GSShaderResourcesArray->Length; i++)
                {
                    GSShaderResourcesArray[i] = nativeObject->GSShaderResources[i];
                }
            }
            return GSShaderResourcesArray;
        }
    }
    /// <summary>
    /// Array of geometry-shader constant buffers. The array is a multi-byte bitmask where each bit represents one buffer slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.GSConstantBuffers)</para>
    /// </summary>
    property array<SByte>^ GSConstantBuffers
    {
        array<SByte>^ get()
        {
            if (GSConstantBuffersArray == nullptr)
            {
                GSConstantBuffersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT));
                for (int i=0; i < GSConstantBuffersArray->Length; i++)
                {
                    GSConstantBuffersArray[i] = nativeObject->GSConstantBuffers[i];
                }
            }
            return GSConstantBuffersArray;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the pixel shader state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.PS)</para>
    /// </summary>
    property SByte PS
    {
        SByte get()
        {
            return (SByte)(nativeObject->PS);
        }
        void set(SByte value)
        {
            nativeObject->PS = (BYTE)value;
        }
    }
    /// <summary>
    /// Array of pixel-shader samplers. The array is a multi-byte bitmask where each bit represents one sampler slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.PSSamplers)</para>
    /// </summary>
    property array<SByte>^ PSSamplers
    {
        array<SByte>^ get()
        {
            if (PSSamplersArray == nullptr)
            {
                PSSamplersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT));
                for (int i=0; i < PSSamplersArray->Length; i++)
                {
                    PSSamplersArray[i] = nativeObject->PSSamplers[i];
                }
            }
            return PSSamplersArray;
        }
    }
    /// <summary>
    /// Array of pixel-shader resources. The array is a multi-byte bitmask where each bit represents one resource slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.PSShaderResources)</para>
    /// </summary>
    property array<SByte>^ PSShaderResources
    {
        array<SByte>^ get()
        {
            if (PSShaderResourcesArray == nullptr)
            {
                PSShaderResourcesArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT));
                for (int i=0; i < PSShaderResourcesArray->Length; i++)
                {
                    PSShaderResourcesArray[i] = nativeObject->PSShaderResources[i];
                }
            }
            return PSShaderResourcesArray;
        }
    }
    /// <summary>
    /// Array of pixel-shader constant buffers. The array is a multi-byte bitmask where each bit represents one constant buffer slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.PSConstantBuffers)</para>
    /// </summary>
    property array<SByte>^ PSConstantBuffers
    {
        array<SByte>^ get()
        {
            if (PSConstantBuffersArray == nullptr)
            {
                PSConstantBuffersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT));
                for (int i=0; i < PSConstantBuffersArray->Length; i++)
                {
                    PSConstantBuffersArray[i] = nativeObject->PSConstantBuffers[i];
                }
            }
            return PSConstantBuffersArray;
        }
    }
    /// <summary>
    /// Array of vertex buffers. The array is a multi-byte bitmask where each bit represents one resource slot.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.IAVertexBuffers)</para>
    /// </summary>
    property array<SByte>^ IAVertexBuffers
    {
        array<SByte>^ get()
        {
            if (IAVertexBuffersArray == nullptr)
            {
                IAVertexBuffersArray = gcnew array<SByte>(D3D10_BYTES_FROM_BITS(D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT));
                for (int i=0; i < IAVertexBuffersArray->Length; i++)
                {
                    IAVertexBuffersArray[i] = nativeObject->IAVertexBuffers[i];
                }
            }
            return IAVertexBuffersArray;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the index buffer state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.IAIndexBuffer)</para>
    /// </summary>
    property SByte IAIndexBuffer
    {
        SByte get()
        {
            return (SByte)(nativeObject->IAIndexBuffer);
        }
        void set(SByte value)
        {
            nativeObject->IAIndexBuffer = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the input layout state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.IAInputLayout)</para>
    /// </summary>
    property SByte IAInputLayout
    {
        SByte get()
        {
            return (SByte)(nativeObject->IAInputLayout);
        }
        void set(SByte value)
        {
            nativeObject->IAInputLayout = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the primitive topology state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.IAPrimitiveTopology)</para>
    /// </summary>
    property SByte IAPrimitiveTopology
    {
        SByte get()
        {
            return (SByte)(nativeObject->IAPrimitiveTopology);
        }
        void set(SByte value)
        {
            nativeObject->IAPrimitiveTopology = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the render targets states.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.OMRenderTargets)</para>
    /// </summary>
    property SByte OMRenderTargets
    {
        SByte get()
        {
            return (SByte)(nativeObject->OMRenderTargets);
        }
        void set(SByte value)
        {
            nativeObject->OMRenderTargets = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the depth-stencil state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.OMDepthStencilState)</para>
    /// </summary>
    property SByte OMDepthStencilState
    {
        SByte get()
        {
            return (SByte)(nativeObject->OMDepthStencilState);
        }
        void set(SByte value)
        {
            nativeObject->OMDepthStencilState = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the blend state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.OMBlendState)</para>
    /// </summary>
    property SByte OMBlendState
    {
        SByte get()
        {
            return (SByte)(nativeObject->OMBlendState);
        }
        void set(SByte value)
        {
            nativeObject->OMBlendState = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the viewports states.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.RSViewports)</para>
    /// </summary>
    property SByte RSViewports
    {
        SByte get()
        {
            return (SByte)(nativeObject->RSViewports);
        }
        void set(SByte value)
        {
            nativeObject->RSViewports = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the scissor rectangles states.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.RSScissorRects)</para>
    /// </summary>
    property SByte RSScissorRects
    {
        SByte get()
        {
            return (SByte)(nativeObject->RSScissorRects);
        }
        void set(SByte value)
        {
            nativeObject->RSScissorRects = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the rasterizer state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.RSRasterizerState)</para>
    /// </summary>
    property SByte RSRasterizerState
    {
        SByte get()
        {
            return (SByte)(nativeObject->RSRasterizerState);
        }
        void set(SByte value)
        {
            nativeObject->RSRasterizerState = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the stream-out buffers states.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.SOBuffers)</para>
    /// </summary>
    property SByte SOBuffers
    {
        SByte get()
        {
            return (SByte)(nativeObject->SOBuffers);
        }
        void set(SByte value)
        {
            nativeObject->SOBuffers = (BYTE)value;
        }
    }
    /// <summary>
    /// Boolean value indicating whether to save the predication state.
    /// <para>(Also see DirectX SDK: D3D10_STATE_BLOCK_MASK.Predication)</para>
    /// </summary>
    property SByte Predication
    {
        SByte get()
        {
            return (SByte)(nativeObject->Predication);
        }
        void set(SByte value)
        {
            nativeObject->Predication = (BYTE)value;
        }
    }
public:
    StateBlockMask()
    {
        nativeObject.Set(new D3D10_STATE_BLOCK_MASK());
    }
internal:
    AutoPointer<D3D10_STATE_BLOCK_MASK> nativeObject;
internal:
    StateBlockMask(D3D10_STATE_BLOCK_MASK* pStateBlockMask)
    {
        nativeObject.Set(pStateBlockMask);
    }
    StateBlockMask(D3D10_STATE_BLOCK_MASK* pStateBlockMask, bool deletable)
    {
        nativeObject.Set(pStateBlockMask, deletable);
    }
private:
        static int VSSamplersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT);
        array<SByte>^ VSSamplersArray;
        static int VSShaderResourcesArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT);
        array<SByte>^ VSShaderResourcesArray;
        static int VSConstantBuffersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT);
        array<SByte>^ VSConstantBuffersArray;
        static int GSSamplersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT);
        array<SByte>^ GSSamplersArray;
        static int GSShaderResourcesArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT);
        array<SByte>^ GSShaderResourcesArray;
        static int GSConstantBuffersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT);
        array<SByte>^ GSConstantBuffersArray;
        static int PSSamplersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT);
        array<SByte>^ PSSamplersArray;
        static int PSShaderResourcesArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT);
        array<SByte>^ PSShaderResourcesArray;
        static int PSConstantBuffersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT);
        array<SByte>^ PSConstantBuffersArray;
        static int IAVertexBuffersArrayLength = D3D10_BYTES_FROM_BITS(D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT);
        array<SByte>^ IAVertexBuffersArray;
};
/// <summary>
/// Specifies data for initializing a subresource.
/// <para>(Also see DirectX SDK: D3D10_SUBRESOURCE_DATA)</para>
/// </summary>
public ref struct SubresourceData 
{
public:
    /// <summary>
    /// Pointer to the initialization data.
    /// <para>(Also see DirectX SDK: D3D10_SUBRESOURCE_DATA.pSysMem)</para>
    /// </summary>
    property IntPtr SysMem
    {
        IntPtr get()
        {
            return IntPtr((void*)nativeObject->pSysMem);
        }
        void set(IntPtr value)
        {
            nativeObject->pSysMem = value.ToPointer();
        }
    }
    /// <summary>
    /// Pitch of the memory (in bytes). System-memory pitch is used only for 2D and 3D texture data as it is has no meaning for the other resource types.
    /// <para>(Also see DirectX SDK: D3D10_SUBRESOURCE_DATA.SysMemPitch)</para>
    /// </summary>
    property UInt32 SysMemPitch
    {
        UInt32 get()
        {
            return (nativeObject->SysMemPitch);
        }
        void set(UInt32 value)
        {
            nativeObject->SysMemPitch = value;
        }
    }
    /// <summary>
    /// Size of one depth level (in bytes). System-memory-slice pitch is only used for 3D texture data as it has no meaning for the other resource types.
    /// <para>(Also see DirectX SDK: D3D10_SUBRESOURCE_DATA.SysMemSlicePitch)</para>
    /// </summary>
    property UInt32 SysMemSlicePitch
    {
        UInt32 get()
        {
            return (nativeObject->SysMemSlicePitch);
        }
        void set(UInt32 value)
        {
            nativeObject->SysMemSlicePitch = value;
        }
    }
public:
    SubresourceData()
    {
        nativeObject.Set(new D3D10_SUBRESOURCE_DATA());
    }
internal:
    AutoPointer<D3D10_SUBRESOURCE_DATA> nativeObject;
internal:
    SubresourceData(D3D10_SUBRESOURCE_DATA* pSubresourceData)
    {
        nativeObject.Set(pSubresourceData);
    }
    SubresourceData(D3D10_SUBRESOURCE_DATA* pSubresourceData, bool deletable)
    {
        nativeObject.Set(pSubresourceData, deletable);
    }
};
/// <summary>
/// Describes an effect technique.
/// <para>(Also see DirectX SDK: D3D10_TECHNIQUE_DESC)</para>
/// </summary>
public ref struct TechniqueDescription 
{
public:
    /// <summary>
    /// A string that contains the technique name; otherwise NULL.
    /// <para>(Also see DirectX SDK: D3D10_TECHNIQUE_DESC.Name)</para>
    /// </summary>
    property String^ Name
    {
        String^ get()
        {
            if (nativeObject->Name == NULL)
            {
                return nullptr;
            }
            return gcnew String(nativeObject->Name);
        }

        void set(String^ value)
        {
            if (String::IsNullOrEmpty(value))
            {
                throw gcnew ArgumentNullException("Name", "Name cannot be null or empty");
            }

            if (context == nullptr)
            {
                context = gcnew marshal_context();
            }

            nativeObject->Name = context->marshal_as<const char*>(value);
        }
    }
    /// <summary>
    /// The number of passes in the technique.
    /// <para>(Also see DirectX SDK: D3D10_TECHNIQUE_DESC.Passes)</para>
    /// </summary>
    property UInt32 Passes
    {
        UInt32 get()
        {
            return (nativeObject->Passes);
        }
        void set(UInt32 value)
        {
            nativeObject->Passes = value;
        }
    }
    /// <summary>
    /// The number of annotations.
    /// <para>(Also see DirectX SDK: D3D10_TECHNIQUE_DESC.Annotations)</para>
    /// </summary>
    property UInt32 Annotations
    {
        UInt32 get()
        {
            return (nativeObject->Annotations);
        }
        void set(UInt32 value)
        {
            nativeObject->Annotations = value;
        }
    }
public:
    TechniqueDescription()
    {
        nativeObject.Set(new D3D10_TECHNIQUE_DESC());
    }
internal:
    AutoPointer<D3D10_TECHNIQUE_DESC> nativeObject;
internal:
    TechniqueDescription(D3D10_TECHNIQUE_DESC* pTechniqueDescription)
    {
        nativeObject.Set(pTechniqueDescription);
    }
    TechniqueDescription(D3D10_TECHNIQUE_DESC* pTechniqueDescription, bool deletable)
    {
        nativeObject.Set(pTechniqueDescription, deletable);
    }
private:
    marshal_context^ context;
};
/// <summary>
/// Defines the dimensions of a viewport.
/// <para>(Also see DirectX SDK: D3D10_VIEWPORT)</para>
/// </summary>
public ref struct Viewport 
{
public:
    /// <summary>
    /// X position of the left hand side of the viewport. Must be between -16384 and 16383.
    /// <para>(Also see DirectX SDK: D3D10_VIEWPORT.TopLeftX)</para>
    /// </summary>
    property Int32 TopLeftX
    {
        Int32 get()
        {
            return (Int32)(nativeObject->TopLeftX);
        }
        void set(Int32 value)
        {
            nativeObject->TopLeftX = (INT)value;
        }
    }
    /// <summary>
    /// Y position of the top of the viewport. Must be between -16384 and 16383.
    /// <para>(Also see DirectX SDK: D3D10_VIEWPORT.TopLeftY)</para>
    /// </summary>
    property Int32 TopLeftY
    {
        Int32 get()
        {
            return (Int32)(nativeObject->TopLeftY);
        }
        void set(Int32 value)
        {
            nativeObject->TopLeftY = (INT)value;
        }
    }
    /// <summary>
    /// Width of the viewport. Must be between 0 and 16383.
    /// <para>(Also see DirectX SDK: D3D10_VIEWPORT.Width)</para>
    /// </summary>
    property UInt32 Width
    {
        UInt32 get()
        {
            return (nativeObject->Width);
        }
        void set(UInt32 value)
        {
            nativeObject->Width = value;
        }
    }
    /// <summary>
    /// Height of the viewport. Must be between 0 and 16383.
    /// <para>(Also see DirectX SDK: D3D10_VIEWPORT.Height)</para>
    /// </summary>
    property UInt32 Height
    {
        UInt32 get()
        {
            return (nativeObject->Height);
        }
        void set(UInt32 value)
        {
            nativeObject->Height = value;
        }
    }
    /// <summary>
    /// Minimum depth of the viewport. Must be between 0 and 1.
    /// <para>(Also see DirectX SDK: D3D10_VIEWPORT.MinDepth)</para>
    /// </summary>
    property Single MinDepth
    {
        Single get()
        {
            return (nativeObject->MinDepth);
        }
        void set(Single value)
        {
            nativeObject->MinDepth = value;
        }
    }
    /// <summary>
    /// Maximum depth of the viewport. Must be between 0 and 1.
    /// <para>(Also see DirectX SDK: D3D10_VIEWPORT.MaxDepth)</para>
    /// </summary>
    property Single MaxDepth
    {
        Single get()
        {
            return (nativeObject->MaxDepth);
        }
        void set(Single value)
        {
            nativeObject->MaxDepth = value;
        }
    }
public:
    Viewport()
    {
        nativeObject.Set(new D3D10_VIEWPORT());
        ZeroMemory(nativeObject.Get(), sizeof(D3D10_VIEWPORT));
    }
internal:
    AutoPointer<D3D10_VIEWPORT> nativeObject;
internal:
    Viewport(D3D10_VIEWPORT* pViewport)
    {
        nativeObject.Set(pViewport);
    }
    Viewport(D3D10_VIEWPORT* pViewport, bool deletable)
    {
        nativeObject.Set(pViewport, deletable);
    }

    Viewport(const D3D10_VIEWPORT& viewport)
    {
        nativeObject.Set(new D3D10_VIEWPORT());
        ZeroMemory(nativeObject.Get(), sizeof(D3D10_VIEWPORT));

        memcpy(nativeObject.Get(), &viewport, sizeof(D3D10_VIEWPORT));
    }
};
} } } }
